PKIZ __init__.pynu[PKIZyrsrPKIZ^44'__pycache__/test_isfile.cpython-311.pycnu[ bg,4ddlZddlmZddlZddlmZeejjdZ e dz e dz e dz e dz dz e dz dz e d z dz e d z dz e d z dz e d z dz e d z dz e dz dz e dz dz e dz dz e dz dz gZ GddZ dS)N)Path)assert_zpy.typedz __init__.pyiz ctypeslib.pyicore distutilsf2pyfftliblinalgma matrixlib polynomialrandomtestingceZdZdZdS) TestIsFilecrtD].}ttj|/dS)z2Test if all ``.pyi`` files are properly installed.N)FILESrospathisfile)selffiles q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/test_isfile.py test_isfilezTestIsFile.test_isfiles: * *D BGNN4(( ) ) ) ) * *N)__name__ __module__ __qualname__rrrrrs#*****rr) rpathlibrnumpynp numpy.testingr__file__parentsROOTrrrrrr's0 !!!!!! tBK #:>?6MN";'6MN"5L>!5L>!8On$4K. ;'<.(8On$9~% $**********rPKIZ'O(__pycache__/test_runtime.cpython-311.pycnu[ bg UdZddlmZddlmZmZmZmZmZm Z ddl Z ddl Z ddl mZddlmZGddeZeejejje jZeejejjeeejejjeeejddedZe jd ee ddZe jd ee ddZ e jd ee ddZ!e jd ee ddZ"ddZ#ej$e j%dfej&e j'dfej(e j'dfej)dgfdZ*de+d<e jde*,e* GddZ-dS)z)Test the runtime usage of `numpy.typing`.) annotations)get_type_hintsUnion NamedTupleget_args get_originAnyNc.eZdZUded<ded<ded<dS)TypeTuptypetypztuple[type, ...]argsz None | typeoriginN)__name__ __module__ __qualname____annotations__r/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/test_runtime.pyr r s3 IIIrr r) ArrayLike DTypeLikeNBitBaseNDArrayzname,tup)idsnamer tupreturnNonecP|j|j}}t|}||ksJdS)zTest `typing.get_args`.N)r rrrrr refouts r test_get_argsr$$s-wC 3--C #::::::rcP|j|j}}t|}||ksJdS)zTest `typing.get_origin`.N)r rrr!s rtest_get_originr&,s-w C S//C #::::::rc|j}d}|dd|_t|}|tdd}||ksJdS)zTest `typing.get_type_hints`.cdSNras rfuncz!test_get_type_hints..func;rNr+rr rrr )rrr r,r#r"s rtest_get_type_hintsr04sW 'C!$55D   CtDzz * *C #::::::rcd||j}}d}|dd|_t|}|tdd}||ksJdS)zATest `typing.get_type_hints` with string-representation of types.znpt.cdSr)rr*s rr,z%test_get_type_hints_str..funcJr-rNr.r/)rrtyp_strr r,r#r"s rtest_get_type_hints_strr4Csa!$==#'SG!(D99D   CtDzz * *C #::::::rczt}ttj}||ksJdS)zCTest that ``TYPES.keys()`` and ``numpy.typing.__all__`` are synced.N)TYPESkeyssetnpt__all__)r7r"s r test_keysr;Rs/ ::<pytestxfail issubclassr rKs rtest_issubclassz#TestRuntimeProtocol.test_issubclassgsg $% % % LN   $s))S)))))d4jj#.......rN)rErFrGrHrr)rrrrMrSrrrrDrDas<))))//////rrD)rr rr rr)rr).__doc__ __future__rtypingrrrrrr rPnumpynp numpy.typingr9 numpy._typing_typingrOr r__args__ndarray NDArrayTuprrrr6mark parametrizeitemsr7r$r&r0r4r;r>int64r?aranger@rArBrvaluesrDrrrresZ///"""""" j WS[#+"6 C C  (>FF (>FF b$//   U[[]] EEFEU[[]] EEFEU[[]] EE   FE U[[]] EE   FE *HBHQKK8*IBIbMM:2IBIbMMB,qc2 22 I$4$4$6$6INNej.j/ej.0edej.4d&e3e%dSd:Z?d;Z@ejAd<ZBdWd>ZCej.j/ej.0edej.4d&e3e#dSd?ZDd@dAdBdCdDdEdFdGdHdIdJdKdL ZEej.j/ej.0eddQdMZFdS)X) annotationsN) defaultdict)Iterator)IO TYPE_CHECKING)_PRECISION_DICT_EXTENDED_PRECISION_LIST_C_INTP)apiFT) ParameterSetdatapassfailrevealmisczmypy.iniz .mypy_cachezdict[str, list[str]] OUTPUT_MYPYkeystrreturnctj|\}}tj||dddS)zySplit at the first occurrence of the ``:`` character. Windows drive-letters (*e.g.* ``C:``) are ignored herein. :r)ospath splitdrivejoinsplit)rdrivetails q/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/test_typing.py _key_funcr!.sF '$$S))KE4 7<<tzz#q11!4 5 55msgc~tj|\}}|dddS)z'Strip the filename from a mypy message.rr)rrrr)r#_rs r _strip_filenamer'7s4g  %%GAt ::c1  b !!r"match re.Match[str]c6|dS)z4`re.sub` helper function for stripping module names.r)groups)r(s r strip_funcr,=s <<>>! r"zMypy is not installed)reasonmodule)scopeautouseNonectjtrFt tjddrtjtttttfD]}tjdtdt|g\}}}|rt!jd|n|dvrt!jd|d||d d }t'j|d t, }t.d |DdS)zClears the cache and run mypy before running any of the typing tests. The mypy results are cached in `OUTPUT_MYPY` for further use. The cache refresh can be skipped using NUMPY_TYPING_TEST_CLEAR_CACHE=0 pytest numpy/typing/tests NUMPY_TYPING_TEST_CLEAR_CACHETz --config-filez --cache-dirz Unexpected mypy standard error >rrzUnexpected mypy exit code:  * )rc3BK|]\}}||t|fVdSN)list.0kvs r zrun_mypy..es5BBDAqBAtAww<BBBBBBr"N)rrisdir CACHE_DIRboolenvirongetshutilrmtreePASS_DIR REVEAL_DIRFAIL_DIRMISC_DIRr runMYPY_INIpytestrreplace itertoolsgroupbyrr!rupdate) directorystdoutstderr exit_codeiterators r run_mypyrWBsN  i  !  ?FF G G!  i    Hh?CC $'G      - % % !   O KEVEE F F F F f $ $ KMiMMVMM N N NR(($V\\$%7%7YGGGBBHBBBBBBB#CCr"rRIterator[ParameterSet]c#Ktj|D]i\}}}|D]`}tj|\}}|dvr8tj||}t j||VajdS)N)z.pyiz.py)id)rwalkrsplitextrrMparam)rRrootr&filesfname short_fnameextfullpaths r get_test_casesrdhs'),,==a = =E!w//66 Ko%%7<<e44l8 <<<<<<  ===r"rct}||vr9d}|dd||Dz }t|dS)NzUnexpected mypy output r7c34K|]}t|VdSr9)r')r<r>s r r?ztest_success..ys*GG++GGGGGGr")rrAssertionError)r output_mypyr#s r test_successriqsY K {* tyyGG[5FGGGGGGS!!!r"cbd}t|5}|}dddn #1swxYwYtd}t}||vsJ||D]}t |ddd}t jd|}|td|t| d}||xx|dz cc<t|D]\} } | dz}| d sd | vr||vr(||dz } d | vr[| d \} } }||}|}t|| |||t!jd |d||dS)NTcdS)Nr6rlr"r ztest_fail..sr"r7rrz"(?P\d+): (error|note): .+$zUnexpected error line format: lineno#z E:z# E: # E: zUnexpected mypy output at line r4)open readlinesrrr'rrer( ValueErrorintgroup enumerate startswith partitionstrip _test_failrMr)r__tracebackhide__finlineserrorsrh error_liner(rniline target_line expressionr&markerexpected_errors r test_failr}s9 d s                 $ $FK ;    !$' , , $Z0066tQ??B  1    =JjJJKK KU[[**++vZ++++U##4Q OOC  T!!fF&:&: FQJ' [ $/$9$9)$D$D !J6#F^1133N\\^^F tZ H H H H KN&NNfVnNN    s 377z9Extra error at line {} Expression: {} Extra error: {!r} zTError mismatch at line {} Expression: {} Expected error: {!r} Observed error: {!r} rerrorr None | strrnruc|)tt|||||vr*tt||||dSr9)rg _FAIL_MSG1format _FAIL_MSG2)rrrrrns r r{r{sjZ..vz5IIJJJ n $ $Z.. J      % $r"dict[str, str]cddddddddd d d d d d }i}i}|D]V\}}tt|}|jj|jjf}||d|||<W|S)Nc_ubytec_ushortc_uintc_ulong c_ulonglongc_bytec_shortc_intc_long c_longlongc_floatc_double c_longdouble) ubyteushortuintcuint ulonglongbyteshortintcint_longlongsingledouble longdoublectypes.)itemsgetattrnpdtypekinditemsize setdefault)dctretvisitednp_namect_name np_scalarrs r _construct_ctypes_dictrs" $  C( C*,GIIKKDD(GB((** #Y_%=>))#/B/B/BCCG Jr"cdtjD}idddddddd d d d d ddddddddddddddddddd d!d"d#id$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5|d6d7d8d5|d9d7d:d5|d;d7dd5|d?d7d@d5|dAd7dBdC|d6d7dDdC|d9d7dEdC|d;d7dC|d=d7dC|d?d7dC|dAd7dF|dGd7dF|dHd7dF|dId7dF|dJd7dK|dHdL|dHd7dK|dIdL|dId7dK|dJdL|dJd7|d?dMtdN S)ONcti|]5\}}|dd|dd6S).r%numpyz numpy._typing)rrNr;s r z*_construct_format_dict..sK , , , 1a 773<< QYYw@@ , , ,r"uint8z*numpy.unsignedinteger[numpy._typing._8Bit]uint16z+numpy.unsignedinteger[numpy._typing._16Bit]uint32z+numpy.unsignedinteger[numpy._typing._32Bit]uint64z+numpy.unsignedinteger[numpy._typing._64Bit]uint128z,numpy.unsignedinteger[numpy._typing._128Bit]uint256z,numpy.unsignedinteger[numpy._typing._256Bit]int8z(numpy.signedinteger[numpy._typing._8Bit]int16z)numpy.signedinteger[numpy._typing._16Bit]int32z)numpy.signedinteger[numpy._typing._32Bit]int64z)numpy.signedinteger[numpy._typing._64Bit]int128z*numpy.signedinteger[numpy._typing._128Bit]int256z*numpy.signedinteger[numpy._typing._256Bit]float16z$numpy.floating[numpy._typing._16Bit]float32z$numpy.floating[numpy._typing._32Bit]float64z$numpy.floating[numpy._typing._64Bit]float80z$numpy.floating[numpy._typing._80Bit]float96z$numpy.floating[numpy._typing._96Bit]float128z%numpy.floating[numpy._typing._128Bit]float256z%numpy.floating[numpy._typing._256Bit] complex64zAnumpy.complexfloating[numpy._typing._32Bit, numpy._typing._32Bit] complex128zAnumpy.complexfloating[numpy._typing._64Bit, numpy._typing._64Bit] complex160zAnumpy.complexfloating[numpy._typing._80Bit, numpy._typing._80Bit] complex192zAnumpy.complexfloating[numpy._typing._96Bit, numpy._typing._96Bit] complex256zCnumpy.complexfloating[numpy._typing._128Bit, numpy._typing._128Bit] complex512zCnumpy.complexfloating[numpy._typing._256Bit, numpy._typing._256Bit]rznumpy.unsignedinteger[ _NBitByte]r _NBitShortr _NBitIntCuintp _NBitIntPr_NBitIntr _NBitLongLongrznumpy.signedinteger[rrznumpy.floating[ _NBitHalf _NBitSingle _NBitDouble_NBitLongDoubleznumpy.complexfloating[z, r) intprrhalfrrrcsinglecdouble clongdoublerc_intp)rrr )rs r _construct_format_dictrs , ,"(** , , ,C@ =@ ?@  ?@  ? @  A @  A @  :@  <@  <@  <@  >@  >@  9@  9@  9@  9!@ " 9#@ @ $ ;%@ & ;'@ ( E)@ , F-@ 0 F1@ 4 F5@ 8 H9@ < H=@ B =#k*:===C@ D ?3|+<???E@ F =#k*:===G@ H =#k*:===I@ J ;Z;;;K@ L Ec/.BEEEM@ N :s;'7:::O@ P <L(9<<AAADM*DD.1-.@DDDDM*DD.1-.@DDD D%& D D*-.?*@ D D D  O&G%%@ @ @ @r" FORMAT_DICTfileIO[str]&tuple[npt.NDArray[np.str_], list[str]]c|dd}tj|ddj\}}}d|}ttj d|}d|D}|j d i|}||dfS) aExtract and parse all ``" # E: "`` comments from the passed file-like object. All format keys will be substituted for their respective value from `FORMAT_DICT`, *e.g.* ``"{float64}"`` becomes ``"numpy.floating[numpy._typing._64Bit]"``. r5r6r7rp)sepz/nz \{(.*?)\}c Ni|]"}|t|d|d#S)z)rrD)r<r=s r rz"_parse_reveals..FsD  ;??1@!@@@ A Ar"rl) readrNrcharryrTrsetrsfindallr) rstringexpression_arrayr&comments_arraycommentskey_setkwargsfmt_strs r _parse_revealsr3sYY[[ b ) )F+-'*;*; T +<++(ayy((H"*\84455G Fho''''G W]]400 00r"c d}t|5}t|\}}dddn #1swxYwYt}||vsJ||D]}t|}t jd|}|t d|t|ddz }d|vsJ||} ||} t|| | |d|zdS)z[Validate that mypy correctly infers the return-types of the expressions in `path`. TNz(?P\d+): note: .+$Unexpected reveal line format: rnrzRevealed type is) rqrrr'rsr(rtrurv _test_reveal) rr|r}r reveal_listrhrr(rnrrs r test_revealrOsW d 1 1 X  D     ; " " ".11$77KKK(((((r"rrrrrrrrrrrr)  ctjtd}t}||vsJt |5}|}dddn #1swxYwY||D]}|d^}}}}t|}t|} || dz  d} | }|dvsJt| tvrD|dkrtd| tt| } t!|| | || |dkrd} t#|| | || dS) Nzextended_precision.pyirrr7>noterrrzModule has no attribute)rrrrJrrqrrrr'rurstriprzLINENO_MAPPINGr rtrrr{) rrhfexpression_list_msgr&_linenomsg_typr#rnrrs r test_extended_precisionr.s 7<<": ; ;DK ;     d(q++--(((((((((((((((D!BB$(JJsOO!GWcc""W$VaZ077== --//+++++ & !%= = ='!! !K6!K!KLLL$^F%;<T:vsFCCCC'!!24VS&AAA%BBsA##A'*A')rrrr)r#rrr)r(r)rr)rr1)rRrrrX)rrrr1) rrrrrrrrrnrurr1)rr)rrrr) rrrrrrrrrnrurr1)G __future__rimportlib.utilr rOrrsrE collectionsrcollections.abcrtypingrrrMrr numpy.typingnptnumpy.typing.mypy_pluginrr r mypyr NO_MYPY ImportError_pytest.mark.structuresr rrr__file__DATA_DIRrGrIrHrJrLrAr__annotations__r!r'r,markslowskipiffixturerWrd parametrizerirrrr{rrrrQrrrcompilerrrr(r.rlr"r rDs""""""" ######$$$$$$$$$$$$$$  GGGGG 5544444 7<<116 : : 7<<& ) ) 7<<& ) ) W\\(H - - 7<<& ) ) 7<<* - - GLL= 1 1 %' &&&&6666""""  G$;<<h--- C C C.-=< CF====G$;<<!9!9::""";:=<"G$;<<!9!9::&&&;:=<&R       @DDDDR5466 6666 ))++,,,11118G$;<< !;!;<<GGG=<=<G6 ,--    &G$;<<!9!9:: ) ) );:=< )    G$;<<BBB=<BBBs AAAPKIZaE۞  data/fail/arithmetic.pyinu[from typing import Any import numpy as np b_ = np.bool_() dt = np.datetime64(0, "D") td = np.timedelta64(0, "D") AR_b: np.ndarray[Any, np.dtype[np.bool_]] AR_u: np.ndarray[Any, np.dtype[np.uint32]] AR_i: np.ndarray[Any, np.dtype[np.int64]] AR_f: np.ndarray[Any, np.dtype[np.float64]] AR_c: np.ndarray[Any, np.dtype[np.complex128]] AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] AR_M: np.ndarray[Any, np.dtype[np.datetime64]] ANY: Any AR_LIKE_b: list[bool] AR_LIKE_u: list[np.uint32] AR_LIKE_i: list[int] AR_LIKE_f: list[float] AR_LIKE_c: list[complex] AR_LIKE_m: list[np.timedelta64] AR_LIKE_M: list[np.datetime64] # Array subtraction # NOTE: mypys `NoReturn` errors are, unfortunately, not that great _1 = AR_b - AR_LIKE_b # E: Need type annotation _2 = AR_LIKE_b - AR_b # E: Need type annotation AR_i - bytes() # E: No overload variant AR_f - AR_LIKE_m # E: Unsupported operand types AR_f - AR_LIKE_M # E: Unsupported operand types AR_c - AR_LIKE_m # E: Unsupported operand types AR_c - AR_LIKE_M # E: Unsupported operand types AR_m - AR_LIKE_f # E: Unsupported operand types AR_M - AR_LIKE_f # E: Unsupported operand types AR_m - AR_LIKE_c # E: Unsupported operand types AR_M - AR_LIKE_c # E: Unsupported operand types AR_m - AR_LIKE_M # E: Unsupported operand types AR_LIKE_m - AR_M # E: Unsupported operand types # array floor division AR_M // AR_LIKE_b # E: Unsupported operand types AR_M // AR_LIKE_u # E: Unsupported operand types AR_M // AR_LIKE_i # E: Unsupported operand types AR_M // AR_LIKE_f # E: Unsupported operand types AR_M // AR_LIKE_c # E: Unsupported operand types AR_M // AR_LIKE_m # E: Unsupported operand types AR_M // AR_LIKE_M # E: Unsupported operand types AR_b // AR_LIKE_M # E: Unsupported operand types AR_u // AR_LIKE_M # E: Unsupported operand types AR_i // AR_LIKE_M # E: Unsupported operand types AR_f // AR_LIKE_M # E: Unsupported operand types AR_c // AR_LIKE_M # E: Unsupported operand types AR_m // AR_LIKE_M # E: Unsupported operand types AR_M // AR_LIKE_M # E: Unsupported operand types _3 = AR_m // AR_LIKE_b # E: Need type annotation AR_m // AR_LIKE_c # E: Unsupported operand types AR_b // AR_LIKE_m # E: Unsupported operand types AR_u // AR_LIKE_m # E: Unsupported operand types AR_i // AR_LIKE_m # E: Unsupported operand types AR_f // AR_LIKE_m # E: Unsupported operand types AR_c // AR_LIKE_m # E: Unsupported operand types # Array multiplication AR_b *= AR_LIKE_u # E: incompatible type AR_b *= AR_LIKE_i # E: incompatible type AR_b *= AR_LIKE_f # E: incompatible type AR_b *= AR_LIKE_c # E: incompatible type AR_b *= AR_LIKE_m # E: incompatible type AR_u *= AR_LIKE_i # E: incompatible type AR_u *= AR_LIKE_f # E: incompatible type AR_u *= AR_LIKE_c # E: incompatible type AR_u *= AR_LIKE_m # E: incompatible type AR_i *= AR_LIKE_f # E: incompatible type AR_i *= AR_LIKE_c # E: incompatible type AR_i *= AR_LIKE_m # E: incompatible type AR_f *= AR_LIKE_c # E: incompatible type AR_f *= AR_LIKE_m # E: incompatible type # Array power AR_b **= AR_LIKE_b # E: Invalid self argument AR_b **= AR_LIKE_u # E: Invalid self argument AR_b **= AR_LIKE_i # E: Invalid self argument AR_b **= AR_LIKE_f # E: Invalid self argument AR_b **= AR_LIKE_c # E: Invalid self argument AR_u **= AR_LIKE_i # E: incompatible type AR_u **= AR_LIKE_f # E: incompatible type AR_u **= AR_LIKE_c # E: incompatible type AR_i **= AR_LIKE_f # E: incompatible type AR_i **= AR_LIKE_c # E: incompatible type AR_f **= AR_LIKE_c # E: incompatible type # Scalars b_ - b_ # E: No overload variant dt + dt # E: Unsupported operand types td - dt # E: Unsupported operand types td % 1 # E: Unsupported operand types td / dt # E: No overload td % dt # E: Unsupported operand types -b_ # E: Unsupported operand type +b_ # E: Unsupported operand type PKIZaAA data/fail/array_constructors.pyinu[import numpy as np a: np.ndarray generator = (i for i in range(10)) np.require(a, requirements=1) # E: No overload variant np.require(a, requirements="TEST") # E: incompatible type np.zeros("test") # E: incompatible type np.zeros() # E: require at least one argument np.ones("test") # E: incompatible type np.ones() # E: require at least one argument np.array(0, float, True) # E: No overload variant np.linspace(None, 'bob') # E: No overload variant np.linspace(0, 2, num=10.0) # E: No overload variant np.linspace(0, 2, endpoint='True') # E: No overload variant np.linspace(0, 2, retstep=b'False') # E: No overload variant np.linspace(0, 2, dtype=0) # E: No overload variant np.linspace(0, 2, axis=None) # E: No overload variant np.logspace(None, 'bob') # E: No overload variant np.logspace(0, 2, base=None) # E: No overload variant np.geomspace(None, 'bob') # E: No overload variant np.stack(generator) # E: No overload variant np.hstack({1, 2}) # E: No overload variant np.vstack(1) # E: No overload variant np.array([1], like=1) # E: No overload variant PKIZ.data/fail/array_like.pyinu[import numpy as np from numpy._typing import ArrayLike class A: pass x1: ArrayLike = (i for i in range(10)) # E: Incompatible types in assignment x2: ArrayLike = A() # E: Incompatible types in assignment x3: ArrayLike = {1: "foo", 2: "bar"} # E: Incompatible types in assignment scalar = np.int64(1) scalar.__array__(dtype=np.float64) # E: No overload variant array = np.array([1]) array.__array__(dtype=np.float64) # E: No overload variant PKIZE xdata/fail/array_pad.pyinu[import numpy as np import numpy.typing as npt AR_i8: npt.NDArray[np.int64] np.pad(AR_i8, 2, mode="bob") # E: No overload variant PKIZgo}%%data/fail/arrayprint.pyinu[from collections.abc import Callable from typing import Any import numpy as np AR: np.ndarray func1: Callable[[Any], str] func2: Callable[[np.integer[Any]], str] np.array2string(AR, style=None) # E: Unexpected keyword argument np.array2string(AR, legacy="1.14") # E: incompatible type np.array2string(AR, sign="*") # E: incompatible type np.array2string(AR, floatmode="default") # E: incompatible type np.array2string(AR, formatter={"A": func1}) # E: incompatible type np.array2string(AR, formatter={"float": func2}) # E: Incompatible types PKIZ3"data/fail/arrayterator.pyinu[from typing import Any import numpy as np AR_i8: np.ndarray[Any, np.dtype[np.int64]] ar_iter = np.lib.Arrayterator(AR_i8) np.lib.Arrayterator(np.int64()) # E: incompatible type ar_iter.shape = (10, 5) # E: is read-only ar_iter[None] # E: Invalid index type ar_iter[None, 1] # E: Invalid index type ar_iter[np.intp()] # E: Invalid index type ar_iter[np.intp(), ...] # E: Invalid index type ar_iter[AR_i8] # E: Invalid index type ar_iter[AR_i8, :] # E: Invalid index type PKIZD~!data/fail/bitwise_ops.pyinu[import numpy as np i8 = np.int64() i4 = np.int32() u8 = np.uint64() b_ = np.bool_() i = int() f8 = np.float64() b_ >> f8 # E: No overload variant i8 << f8 # E: No overload variant i | f8 # E: Unsupported operand types i8 ^ f8 # E: No overload variant u8 & f8 # E: No overload variant ~f8 # E: Unsupported operand type # mypys' error message for `NoReturn` is unfortunately pretty bad # TODO: Re-enable this once we add support for numerical precision for `number`s # a = u8 | 0 # E: Need type annotation PKIZO7 7 data/fail/char.pyinu[import numpy as np import numpy.typing as npt AR_U: npt.NDArray[np.str_] AR_S: npt.NDArray[np.bytes_] np.char.equal(AR_U, AR_S) # E: incompatible type np.char.not_equal(AR_U, AR_S) # E: incompatible type np.char.greater_equal(AR_U, AR_S) # E: incompatible type np.char.less_equal(AR_U, AR_S) # E: incompatible type np.char.greater(AR_U, AR_S) # E: incompatible type np.char.less(AR_U, AR_S) # E: incompatible type np.char.encode(AR_S) # E: incompatible type np.char.decode(AR_U) # E: incompatible type np.char.join(AR_U, b"_") # E: incompatible type np.char.join(AR_S, "_") # E: incompatible type np.char.ljust(AR_U, 5, fillchar=b"a") # E: incompatible type np.char.ljust(AR_S, 5, fillchar="a") # E: incompatible type np.char.rjust(AR_U, 5, fillchar=b"a") # E: incompatible type np.char.rjust(AR_S, 5, fillchar="a") # E: incompatible type np.char.lstrip(AR_U, chars=b"a") # E: incompatible type np.char.lstrip(AR_S, chars="a") # E: incompatible type np.char.strip(AR_U, chars=b"a") # E: incompatible type np.char.strip(AR_S, chars="a") # E: incompatible type np.char.rstrip(AR_U, chars=b"a") # E: incompatible type np.char.rstrip(AR_S, chars="a") # E: incompatible type np.char.partition(AR_U, b"a") # E: incompatible type np.char.partition(AR_S, "a") # E: incompatible type np.char.rpartition(AR_U, b"a") # E: incompatible type np.char.rpartition(AR_S, "a") # E: incompatible type np.char.replace(AR_U, b"_", b"-") # E: incompatible type np.char.replace(AR_S, "_", "-") # E: incompatible type np.char.split(AR_U, b"_") # E: incompatible type np.char.split(AR_S, "_") # E: incompatible type np.char.rsplit(AR_U, b"_") # E: incompatible type np.char.rsplit(AR_S, "_") # E: incompatible type np.char.count(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.count(AR_S, "a", end=9) # E: incompatible type np.char.endswith(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.endswith(AR_S, "a", end=9) # E: incompatible type np.char.startswith(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.startswith(AR_S, "a", end=9) # E: incompatible type np.char.find(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.find(AR_S, "a", end=9) # E: incompatible type np.char.rfind(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.rfind(AR_S, "a", end=9) # E: incompatible type np.char.index(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.index(AR_S, "a", end=9) # E: incompatible type np.char.rindex(AR_U, b"a", start=[1, 2, 3]) # E: incompatible type np.char.rindex(AR_S, "a", end=9) # E: incompatible type PKIZ\data/fail/chararray.pyinu[import numpy as np from typing import Any AR_U: np.chararray[Any, np.dtype[np.str_]] AR_S: np.chararray[Any, np.dtype[np.bytes_]] AR_S.encode() # E: Invalid self argument AR_U.decode() # E: Invalid self argument AR_U.join(b"_") # E: incompatible type AR_S.join("_") # E: incompatible type AR_U.ljust(5, fillchar=b"a") # E: incompatible type AR_S.ljust(5, fillchar="a") # E: incompatible type AR_U.rjust(5, fillchar=b"a") # E: incompatible type AR_S.rjust(5, fillchar="a") # E: incompatible type AR_U.lstrip(chars=b"a") # E: incompatible type AR_S.lstrip(chars="a") # E: incompatible type AR_U.strip(chars=b"a") # E: incompatible type AR_S.strip(chars="a") # E: incompatible type AR_U.rstrip(chars=b"a") # E: incompatible type AR_S.rstrip(chars="a") # E: incompatible type AR_U.partition(b"a") # E: incompatible type AR_S.partition("a") # E: incompatible type AR_U.rpartition(b"a") # E: incompatible type AR_S.rpartition("a") # E: incompatible type AR_U.replace(b"_", b"-") # E: incompatible type AR_S.replace("_", "-") # E: incompatible type AR_U.split(b"_") # E: incompatible type AR_S.split("_") # E: incompatible type AR_S.split(1) # E: incompatible type AR_U.rsplit(b"_") # E: incompatible type AR_S.rsplit("_") # E: incompatible type AR_U.count(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.count("a", end=9) # E: incompatible type AR_U.endswith(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.endswith("a", end=9) # E: incompatible type AR_U.startswith(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.startswith("a", end=9) # E: incompatible type AR_U.find(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.find("a", end=9) # E: incompatible type AR_U.rfind(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.rfind("a", end=9) # E: incompatible type AR_U.index(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.index("a", end=9) # E: incompatible type AR_U.rindex(b"a", start=[1, 2, 3]) # E: incompatible type AR_S.rindex("a", end=9) # E: incompatible type AR_U == AR_S # E: Unsupported operand types AR_U != AR_S # E: Unsupported operand types AR_U >= AR_S # E: Unsupported operand types AR_U <= AR_S # E: Unsupported operand types AR_U > AR_S # E: Unsupported operand types AR_U < AR_S # E: Unsupported operand types PKIZtZxxdata/fail/comparisons.pyinu[from typing import Any import numpy as np AR_i: np.ndarray[Any, np.dtype[np.int64]] AR_f: np.ndarray[Any, np.dtype[np.float64]] AR_c: np.ndarray[Any, np.dtype[np.complex128]] AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] AR_M: np.ndarray[Any, np.dtype[np.datetime64]] AR_f > AR_m # E: Unsupported operand types AR_c > AR_m # E: Unsupported operand types AR_m > AR_f # E: Unsupported operand types AR_m > AR_c # E: Unsupported operand types AR_i > AR_M # E: Unsupported operand types AR_f > AR_M # E: Unsupported operand types AR_m > AR_M # E: Unsupported operand types AR_M > AR_i # E: Unsupported operand types AR_M > AR_f # E: Unsupported operand types AR_M > AR_m # E: Unsupported operand types AR_i > str() # E: No overload variant AR_i > bytes() # E: No overload variant str() > AR_M # E: Unsupported operand types bytes() > AR_M # E: Unsupported operand types PKIZ02Xdata/fail/constants.pyinu[import numpy as np np.Inf = np.Inf # E: Cannot assign to final np.ALLOW_THREADS = np.ALLOW_THREADS # E: Cannot assign to final np.little_endian = np.little_endian # E: Cannot assign to final np.UFUNC_PYVALS_NAME = "bob" # E: Incompatible types np.CLIP = 2 # E: Incompatible types PKIZ {data/fail/datasource.pyinu[from pathlib import Path import numpy as np path: Path d1: np.DataSource d1.abspath(path) # E: incompatible type d1.abspath(b"...") # E: incompatible type d1.exists(path) # E: incompatible type d1.exists(b"...") # E: incompatible type d1.open(path, "r") # E: incompatible type d1.open(b"...", encoding="utf8") # E: incompatible type d1.open(None, newline="/n") # E: incompatible type PKIZ󩖏NNdata/fail/dtype.pyinu[import numpy as np class Test1: not_dtype = np.dtype(float) class Test2: dtype = float np.dtype(Test1()) # E: No overload variant of "dtype" matches np.dtype(Test2()) # E: incompatible type np.dtype( # E: No overload variant of "dtype" matches { "field1": (float, 1), "field2": (int, 3), } ) PKIZ#data/fail/einsumfunc.pyinu[from typing import Any import numpy as np AR_i: np.ndarray[Any, np.dtype[np.int64]] AR_f: np.ndarray[Any, np.dtype[np.float64]] AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] AR_U: np.ndarray[Any, np.dtype[np.str_]] np.einsum("i,i->i", AR_i, AR_m) # E: incompatible type np.einsum("i,i->i", AR_f, AR_f, dtype=np.int32) # E: incompatible type np.einsum("i,i->i", AR_i, AR_i, out=AR_U) # E: Value of type variable "_ArrayType" of "einsum" cannot be np.einsum("i,i->i", AR_i, AR_i, out=AR_U, casting="unsafe") # E: No overload variant PKIZiBvnndata/fail/false_positives.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] # NOTE: Mypy bug presumably due to the special-casing of heterogeneous tuples; # xref numpy/numpy#20901 # # The expected output should be no different than, e.g., when using a # list instead of a tuple np.concatenate(([1], AR_f8)) # E: Argument 1 to "concatenate" has incompatible type PKIZC&KKdata/fail/flatiter.pyinu[from typing import Any import numpy as np from numpy._typing import _SupportsArray class Index: def __index__(self) -> int: ... a: "np.flatiter[np.ndarray]" supports_array: _SupportsArray a.base = Any # E: Property "base" defined in "flatiter" is read-only a.coords = Any # E: Property "coords" defined in "flatiter" is read-only a.index = Any # E: Property "index" defined in "flatiter" is read-only a.copy(order='C') # E: Unexpected keyword argument # NOTE: Contrary to `ndarray.__getitem__` its counterpart in `flatiter` # does not accept objects with the `__array__` or `__index__` protocols; # boolean indexing is just plain broken (gh-17175) a[np.bool_()] # E: No overload variant of "__getitem__" a[Index()] # E: No overload variant of "__getitem__" a[supports_array] # E: No overload variant of "__getitem__" PKIZJFdata/fail/fromnumeric.pyinu["""Tests for :mod:`numpy.core.fromnumeric`.""" import numpy as np import numpy.typing as npt A = np.array(True, ndmin=2, dtype=bool) A.setflags(write=False) AR_U: npt.NDArray[np.str_] a = np.bool_(True) np.take(a, None) # E: No overload variant np.take(a, axis=1.0) # E: No overload variant np.take(A, out=1) # E: No overload variant np.take(A, mode="bob") # E: No overload variant np.reshape(a, None) # E: No overload variant np.reshape(A, 1, order="bob") # E: No overload variant np.choose(a, None) # E: No overload variant np.choose(a, out=1.0) # E: No overload variant np.choose(A, mode="bob") # E: No overload variant np.repeat(a, None) # E: No overload variant np.repeat(A, 1, axis=1.0) # E: No overload variant np.swapaxes(A, None, 1) # E: No overload variant np.swapaxes(A, 1, [0]) # E: No overload variant np.transpose(A, axes=1.0) # E: No overload variant np.partition(a, None) # E: No overload variant np.partition( # E: No overload variant a, 0, axis="bob" ) np.partition( # E: No overload variant A, 0, kind="bob" ) np.partition( A, 0, order=range(5) # E: Argument "order" to "partition" has incompatible type ) np.argpartition( a, None # E: incompatible type ) np.argpartition( a, 0, axis="bob" # E: incompatible type ) np.argpartition( A, 0, kind="bob" # E: incompatible type ) np.argpartition( A, 0, order=range(5) # E: Argument "order" to "argpartition" has incompatible type ) np.sort(A, axis="bob") # E: No overload variant np.sort(A, kind="bob") # E: No overload variant np.sort(A, order=range(5)) # E: Argument "order" to "sort" has incompatible type np.argsort(A, axis="bob") # E: Argument "axis" to "argsort" has incompatible type np.argsort(A, kind="bob") # E: Argument "kind" to "argsort" has incompatible type np.argsort(A, order=range(5)) # E: Argument "order" to "argsort" has incompatible type np.argmax(A, axis="bob") # E: No overload variant of "argmax" matches argument type np.argmax(A, kind="bob") # E: No overload variant of "argmax" matches argument type np.argmin(A, axis="bob") # E: No overload variant of "argmin" matches argument type np.argmin(A, kind="bob") # E: No overload variant of "argmin" matches argument type np.searchsorted( # E: No overload variant of "searchsorted" matches argument type A[0], 0, side="bob" ) np.searchsorted( # E: No overload variant of "searchsorted" matches argument type A[0], 0, sorter=1.0 ) np.resize(A, 1.0) # E: No overload variant np.squeeze(A, 1.0) # E: No overload variant of "squeeze" matches argument type np.diagonal(A, offset=None) # E: No overload variant np.diagonal(A, axis1="bob") # E: No overload variant np.diagonal(A, axis2=[]) # E: No overload variant np.trace(A, offset=None) # E: No overload variant np.trace(A, axis1="bob") # E: No overload variant np.trace(A, axis2=[]) # E: No overload variant np.ravel(a, order="bob") # E: No overload variant np.compress( # E: No overload variant [True], A, axis=1.0 ) np.clip(a, 1, 2, out=1) # E: No overload variant of "clip" matches argument type np.sum(a, axis=1.0) # E: No overload variant np.sum(a, keepdims=1.0) # E: No overload variant np.sum(a, initial=[1]) # E: No overload variant np.all(a, axis=1.0) # E: No overload variant np.all(a, keepdims=1.0) # E: No overload variant np.all(a, out=1.0) # E: No overload variant np.any(a, axis=1.0) # E: No overload variant np.any(a, keepdims=1.0) # E: No overload variant np.any(a, out=1.0) # E: No overload variant np.cumsum(a, axis=1.0) # E: No overload variant np.cumsum(a, dtype=1.0) # E: No overload variant np.cumsum(a, out=1.0) # E: No overload variant np.ptp(a, axis=1.0) # E: No overload variant np.ptp(a, keepdims=1.0) # E: No overload variant np.ptp(a, out=1.0) # E: No overload variant np.amax(a, axis=1.0) # E: No overload variant np.amax(a, keepdims=1.0) # E: No overload variant np.amax(a, out=1.0) # E: No overload variant np.amax(a, initial=[1.0]) # E: No overload variant np.amax(a, where=[1.0]) # E: incompatible type np.amin(a, axis=1.0) # E: No overload variant np.amin(a, keepdims=1.0) # E: No overload variant np.amin(a, out=1.0) # E: No overload variant np.amin(a, initial=[1.0]) # E: No overload variant np.amin(a, where=[1.0]) # E: incompatible type np.prod(a, axis=1.0) # E: No overload variant np.prod(a, out=False) # E: No overload variant np.prod(a, keepdims=1.0) # E: No overload variant np.prod(a, initial=int) # E: No overload variant np.prod(a, where=1.0) # E: No overload variant np.prod(AR_U) # E: incompatible type np.cumprod(a, axis=1.0) # E: No overload variant np.cumprod(a, out=False) # E: No overload variant np.cumprod(AR_U) # E: incompatible type np.size(a, axis=1.0) # E: Argument "axis" to "size" has incompatible type np.around(a, decimals=1.0) # E: No overload variant np.around(a, out=type) # E: No overload variant np.around(AR_U) # E: incompatible type np.mean(a, axis=1.0) # E: No overload variant np.mean(a, out=False) # E: No overload variant np.mean(a, keepdims=1.0) # E: No overload variant np.mean(AR_U) # E: incompatible type np.std(a, axis=1.0) # E: No overload variant np.std(a, out=False) # E: No overload variant np.std(a, ddof='test') # E: No overload variant np.std(a, keepdims=1.0) # E: No overload variant np.std(AR_U) # E: incompatible type np.var(a, axis=1.0) # E: No overload variant np.var(a, out=False) # E: No overload variant np.var(a, ddof='test') # E: No overload variant np.var(a, keepdims=1.0) # E: No overload variant np.var(AR_U) # E: incompatible type PKIZwoodata/fail/histograms.pyinu[import numpy as np import numpy.typing as npt AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] np.histogram_bin_edges(AR_i8, range=(0, 1, 2)) # E: incompatible type np.histogram(AR_i8, range=(0, 1, 2)) # E: incompatible type np.histogramdd(AR_i8, range=(0, 1)) # E: incompatible type np.histogramdd(AR_i8, range=[(0, 1, 2)]) # E: incompatible type PKIZ{"data/fail/index_tricks.pyinu[import numpy as np AR_LIKE_i: list[int] AR_LIKE_f: list[float] np.ndindex([1, 2, 3]) # E: No overload variant np.unravel_index(AR_LIKE_f, (1, 2, 3)) # E: incompatible type np.ravel_multi_index(AR_LIKE_i, (1, 2, 3), mode="bob") # E: No overload variant np.mgrid[1] # E: Invalid index type np.mgrid[...] # E: Invalid index type np.ogrid[1] # E: Invalid index type np.ogrid[...] # E: Invalid index type np.fill_diagonal(AR_LIKE_f, 2) # E: incompatible type np.diag_indices(1.0) # E: incompatible type PKIZ!!data/fail/lib_function_base.pyinu[from typing import Any import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_m: npt.NDArray[np.timedelta64] AR_M: npt.NDArray[np.datetime64] AR_O: npt.NDArray[np.object_] def func(a: int) -> None: ... np.average(AR_m) # E: incompatible type np.select(1, [AR_f8]) # E: incompatible type np.angle(AR_m) # E: incompatible type np.unwrap(AR_m) # E: incompatible type np.unwrap(AR_c16) # E: incompatible type np.trim_zeros(1) # E: incompatible type np.place(1, [True], 1.5) # E: incompatible type np.vectorize(1) # E: incompatible type np.add_newdoc("__main__", 1.5, "docstring") # E: incompatible type np.place(AR_f8, slice(None), 5) # E: incompatible type np.interp(AR_f8, AR_c16, AR_f8) # E: incompatible type np.interp(AR_c16, AR_f8, AR_f8) # E: incompatible type np.interp(AR_f8, AR_f8, AR_f8, period=AR_c16) # E: No overload variant np.interp(AR_f8, AR_f8, AR_O) # E: incompatible type np.cov(AR_m) # E: incompatible type np.cov(AR_O) # E: incompatible type np.corrcoef(AR_m) # E: incompatible type np.corrcoef(AR_O) # E: incompatible type np.corrcoef(AR_f8, bias=True) # E: No overload variant np.corrcoef(AR_f8, ddof=2) # E: No overload variant np.blackman(1j) # E: incompatible type np.bartlett(1j) # E: incompatible type np.hanning(1j) # E: incompatible type np.hamming(1j) # E: incompatible type np.hamming(AR_c16) # E: incompatible type np.kaiser(1j, 1) # E: incompatible type np.sinc(AR_O) # E: incompatible type np.median(AR_M) # E: incompatible type np.add_newdoc_ufunc(func, "docstring") # E: incompatible type np.percentile(AR_f8, 50j) # E: No overload variant np.percentile(AR_f8, 50, interpolation="bob") # E: No overload variant np.quantile(AR_f8, 0.5j) # E: No overload variant np.quantile(AR_f8, 0.5, interpolation="bob") # E: No overload variant np.meshgrid(AR_f8, AR_f8, indexing="bob") # E: incompatible type np.delete(AR_f8, AR_f8) # E: incompatible type np.insert(AR_f8, AR_f8, 1.5) # E: incompatible type np.digitize(AR_f8, 1j) # E: No overload variant PKIZTY'data/fail/lib_polynomial.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_O: npt.NDArray[np.object_] AR_U: npt.NDArray[np.str_] poly_obj: np.poly1d np.polyint(AR_U) # E: incompatible type np.polyint(AR_f8, m=1j) # E: No overload variant np.polyder(AR_U) # E: incompatible type np.polyder(AR_f8, m=1j) # E: No overload variant np.polyfit(AR_O, AR_f8, 1) # E: incompatible type np.polyfit(AR_f8, AR_f8, 1, rcond=1j) # E: No overload variant np.polyfit(AR_f8, AR_f8, 1, w=AR_c16) # E: incompatible type np.polyfit(AR_f8, AR_f8, 1, cov="bob") # E: No overload variant np.polyval(AR_f8, AR_U) # E: incompatible type np.polyadd(AR_f8, AR_U) # E: incompatible type np.polysub(AR_f8, AR_U) # E: incompatible type np.polymul(AR_f8, AR_U) # E: incompatible type np.polydiv(AR_f8, AR_U) # E: incompatible type 5**poly_obj # E: No overload variant hash(poly_obj) PKIZyudata/fail/lib_utils.pyinu[import numpy as np np.deprecate(1) # E: No overload variant np.deprecate_with_doc(1) # E: incompatible type np.byte_bounds(1) # E: incompatible type np.who(1) # E: incompatible type np.lookfor(None) # E: incompatible type np.safe_eval(None) # E: incompatible type PKIZdata/fail/lib_version.pyinu[from numpy.lib import NumpyVersion version: NumpyVersion NumpyVersion(b"1.8.0") # E: incompatible type version >= b"1.8.0" # E: Unsupported operand types PKIZo**data/fail/linalg.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_O: npt.NDArray[np.object_] AR_M: npt.NDArray[np.datetime64] np.linalg.tensorsolve(AR_O, AR_O) # E: incompatible type np.linalg.solve(AR_O, AR_O) # E: incompatible type np.linalg.tensorinv(AR_O) # E: incompatible type np.linalg.inv(AR_O) # E: incompatible type np.linalg.matrix_power(AR_M, 5) # E: incompatible type np.linalg.cholesky(AR_O) # E: incompatible type np.linalg.qr(AR_O) # E: incompatible type np.linalg.qr(AR_f8, mode="bob") # E: No overload variant np.linalg.eigvals(AR_O) # E: incompatible type np.linalg.eigvalsh(AR_O) # E: incompatible type np.linalg.eigvalsh(AR_O, UPLO="bob") # E: No overload variant np.linalg.eig(AR_O) # E: incompatible type np.linalg.eigh(AR_O) # E: incompatible type np.linalg.eigh(AR_O, UPLO="bob") # E: No overload variant np.linalg.svd(AR_O) # E: incompatible type np.linalg.cond(AR_O) # E: incompatible type np.linalg.cond(AR_f8, p="bob") # E: incompatible type np.linalg.matrix_rank(AR_O) # E: incompatible type np.linalg.pinv(AR_O) # E: incompatible type np.linalg.slogdet(AR_O) # E: incompatible type np.linalg.det(AR_O) # E: incompatible type np.linalg.norm(AR_f8, ord="bob") # E: No overload variant np.linalg.multi_dot([AR_M]) # E: incompatible type PKIZAdata/fail/memmap.pyinu[import numpy as np with open("file.txt", "r") as f: np.memmap(f) # E: No overload variant np.memmap("test.txt", shape=[10, 5]) # E: No overload variant PKIZVItdata/fail/modules.pyinu[import numpy as np np.testing.bob # E: Module has no attribute np.bob # E: Module has no attribute # Stdlib modules in the namespace by accident np.warnings # E: Module has no attribute np.sys # E: Module has no attribute np.os # E: Module has no attribute np.math # E: Module has no attribute # Public sub-modules that are not imported to their parent module by default; # e.g. one must first execute `import numpy.lib.recfunctions` np.lib.recfunctions # E: Module has no attribute np.__NUMPY_SETUP__ # E: Module has no attribute np.__deprecated_attrs__ # E: Module has no attribute np.__expired_functions__ # E: Module has no attribute PKIZPidata/fail/multiarray.pyinu[import numpy as np import numpy.typing as npt i8: np.int64 AR_b: npt.NDArray[np.bool_] AR_u1: npt.NDArray[np.uint8] AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_M: npt.NDArray[np.datetime64] M: np.datetime64 AR_LIKE_f: list[float] def func(a: int) -> None: ... np.where(AR_b, 1) # E: No overload variant np.can_cast(AR_f8, 1) # E: incompatible type np.vdot(AR_M, AR_M) # E: incompatible type np.copyto(AR_LIKE_f, AR_f8) # E: incompatible type np.putmask(AR_LIKE_f, [True, True, False], 1.5) # E: incompatible type np.packbits(AR_f8) # E: incompatible type np.packbits(AR_u1, bitorder=">") # E: incompatible type np.unpackbits(AR_i8) # E: incompatible type np.unpackbits(AR_u1, bitorder=">") # E: incompatible type np.shares_memory(1, 1, max_work=i8) # E: incompatible type np.may_share_memory(1, 1, max_work=i8) # E: incompatible type np.arange(M) # E: No overload variant np.arange(stop=10) # E: No overload variant np.datetime_data(int) # E: incompatible type np.busday_offset("2012", 10) # E: No overload variant np.datetime_as_string("2012") # E: No overload variant np.compare_chararrays("a", b"a", "==", False) # E: No overload variant np.add_docstring(func, None) # E: incompatible type np.nested_iters([AR_i8, AR_i8]) # E: Missing positional argument np.nested_iters([AR_i8, AR_i8], 0) # E: incompatible type np.nested_iters([AR_i8, AR_i8], [0]) # E: incompatible type np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["test"]) # E: incompatible type np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["test"]]) # E: incompatible type np.nested_iters([AR_i8, AR_i8], [[0], [1]], buffersize=1.0) # E: incompatible type PKIZydata/fail/ndarray.pyinu[import numpy as np # Ban setting dtype since mutating the type of the array in place # makes having ndarray be generic over dtype impossible. Generally # users should use `ndarray.view` in this situation anyway. See # # https://github.com/numpy/numpy-stubs/issues/7 # # for more context. float_array = np.array([1.0]) float_array.dtype = np.bool_ # E: Property "dtype" defined in "ndarray" is read-only PKIZ \\data/fail/ndarray_misc.pyinu[""" Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods. More extensive tests are performed for the methods' function-based counterpart in `../from_numeric.py`. """ from typing import Any import numpy as np f8: np.float64 AR_f8: np.ndarray[Any, np.dtype[np.float64]] AR_M: np.ndarray[Any, np.dtype[np.datetime64]] AR_b: np.ndarray[Any, np.dtype[np.bool_]] ctypes_obj = AR_f8.ctypes reveal_type(ctypes_obj.get_data()) # E: has no attribute reveal_type(ctypes_obj.get_shape()) # E: has no attribute reveal_type(ctypes_obj.get_strides()) # E: has no attribute reveal_type(ctypes_obj.get_as_parameter()) # E: has no attribute f8.argpartition(0) # E: has no attribute f8.diagonal() # E: has no attribute f8.dot(1) # E: has no attribute f8.nonzero() # E: has no attribute f8.partition(0) # E: has no attribute f8.put(0, 2) # E: has no attribute f8.setfield(2, np.float64) # E: has no attribute f8.sort() # E: has no attribute f8.trace() # E: has no attribute AR_M.__int__() # E: Invalid self argument AR_M.__float__() # E: Invalid self argument AR_M.__complex__() # E: Invalid self argument AR_b.__index__() # E: Invalid self argument AR_f8[1.5] # E: No overload variant AR_f8["field_a"] # E: No overload variant AR_f8[["field_a", "field_b"]] # E: Invalid index type AR_f8.__array_finalize__(object()) # E: incompatible type PKIZ#]EEdata/fail/nditer.pyinu[import numpy as np class Test(np.nditer): ... # E: Cannot inherit from final class np.nditer([0, 1], flags=["test"]) # E: incompatible type np.nditer([0, 1], op_flags=[["test"]]) # E: incompatible type np.nditer([0, 1], itershape=(1.0,)) # E: incompatible type np.nditer([0, 1], buffersize=1.0) # E: incompatible type PKIZdata/fail/nested_sequence.pyinu[from collections.abc import Sequence from numpy._typing import _NestedSequence a: Sequence[float] b: list[complex] c: tuple[str, ...] d: int e: str def func(a: _NestedSequence[int]) -> None: ... reveal_type(func(a)) # E: incompatible type reveal_type(func(b)) # E: incompatible type reveal_type(func(c)) # E: incompatible type reveal_type(func(d)) # E: incompatible type reveal_type(func(e)) # E: incompatible type PKIZ9  data/fail/npyio.pyinu[import pathlib from typing import IO import numpy.typing as npt import numpy as np str_path: str bytes_path: bytes pathlib_path: pathlib.Path str_file: IO[str] AR_i8: npt.NDArray[np.int64] np.load(str_file) # E: incompatible type np.save(bytes_path, AR_i8) # E: incompatible type np.save(str_file, AR_i8) # E: incompatible type np.savez(bytes_path, AR_i8) # E: incompatible type np.savez(str_file, AR_i8) # E: incompatible type np.savez_compressed(bytes_path, AR_i8) # E: incompatible type np.savez_compressed(str_file, AR_i8) # E: incompatible type np.loadtxt(bytes_path) # E: incompatible type np.fromregex(bytes_path, ".", np.int64) # E: No overload variant np.recfromtxt(bytes_path) # E: incompatible type np.recfromcsv(bytes_path) # E: incompatible type PKIZ5=Cdata/fail/numerictypes.pyinu[import numpy as np # Technically this works, but probably shouldn't. See # # https://github.com/numpy/numpy/issues/16366 # np.maximum_sctype(1) # E: No overload variant np.issubsctype(1, np.int64) # E: incompatible type np.issubdtype(1, np.int64) # E: incompatible type PKIZ؍  data/fail/random.pyinu[import numpy as np from typing import Any SEED_FLOAT: float = 457.3 SEED_ARR_FLOAT: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0, 2, 3, 4]) SEED_ARRLIKE_FLOAT: list[float] = [1.0, 2.0, 3.0, 4.0] SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0) SEED_STR: str = "String seeding not allowed" # default rng np.random.default_rng(SEED_FLOAT) # E: incompatible type np.random.default_rng(SEED_ARR_FLOAT) # E: incompatible type np.random.default_rng(SEED_ARRLIKE_FLOAT) # E: incompatible type np.random.default_rng(SEED_STR) # E: incompatible type # Seed Sequence np.random.SeedSequence(SEED_FLOAT) # E: incompatible type np.random.SeedSequence(SEED_ARR_FLOAT) # E: incompatible type np.random.SeedSequence(SEED_ARRLIKE_FLOAT) # E: incompatible type np.random.SeedSequence(SEED_SEED_SEQ) # E: incompatible type np.random.SeedSequence(SEED_STR) # E: incompatible type seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence() seed_seq.spawn(11.5) # E: incompatible type seed_seq.generate_state(3.14) # E: incompatible type seed_seq.generate_state(3, np.uint8) # E: incompatible type seed_seq.generate_state(3, "uint8") # E: incompatible type seed_seq.generate_state(3, "u1") # E: incompatible type seed_seq.generate_state(3, np.uint16) # E: incompatible type seed_seq.generate_state(3, "uint16") # E: incompatible type seed_seq.generate_state(3, "u2") # E: incompatible type seed_seq.generate_state(3, np.int32) # E: incompatible type seed_seq.generate_state(3, "int32") # E: incompatible type seed_seq.generate_state(3, "i4") # E: incompatible type # Bit Generators np.random.MT19937(SEED_FLOAT) # E: incompatible type np.random.MT19937(SEED_ARR_FLOAT) # E: incompatible type np.random.MT19937(SEED_ARRLIKE_FLOAT) # E: incompatible type np.random.MT19937(SEED_STR) # E: incompatible type np.random.PCG64(SEED_FLOAT) # E: incompatible type np.random.PCG64(SEED_ARR_FLOAT) # E: incompatible type np.random.PCG64(SEED_ARRLIKE_FLOAT) # E: incompatible type np.random.PCG64(SEED_STR) # E: incompatible type np.random.Philox(SEED_FLOAT) # E: incompatible type np.random.Philox(SEED_ARR_FLOAT) # E: incompatible type np.random.Philox(SEED_ARRLIKE_FLOAT) # E: incompatible type np.random.Philox(SEED_STR) # E: incompatible type np.random.SFC64(SEED_FLOAT) # E: incompatible type np.random.SFC64(SEED_ARR_FLOAT) # E: incompatible type np.random.SFC64(SEED_ARRLIKE_FLOAT) # E: incompatible type np.random.SFC64(SEED_STR) # E: incompatible type # Generator np.random.Generator(None) # E: incompatible type np.random.Generator(12333283902830213) # E: incompatible type np.random.Generator("OxFEEDF00D") # E: incompatible type np.random.Generator([123, 234]) # E: incompatible type np.random.Generator(np.array([123, 234], dtype="u4")) # E: incompatible type PKIZ1ldata/fail/rec.pyinu[import numpy as np import numpy.typing as npt AR_i8: npt.NDArray[np.int64] np.rec.fromarrays(1) # E: No overload variant np.rec.fromarrays([1, 2, 3], dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant np.rec.fromrecords(AR_i8) # E: incompatible type np.rec.fromrecords([(1.5,)], dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant np.rec.fromstring("string", dtype=[("f8", "f8")]) # E: No overload variant np.rec.fromstring(b"bytes") # E: No overload variant np.rec.fromstring(b"(1.5,)", dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant with open("test", "r") as f: np.rec.fromfile(f, dtype=[("f8", "f8")]) # E: No overload variant PKIZ[ data/fail/scalars.pyinu[import sys import numpy as np f2: np.float16 f8: np.float64 c8: np.complex64 # Construction np.float32(3j) # E: incompatible type # Technically the following examples are valid NumPy code. But they # are not considered a best practice, and people who wish to use the # stubs should instead do # # np.array([1.0, 0.0, 0.0], dtype=np.float32) # np.array([], dtype=np.complex64) # # See e.g. the discussion on the mailing list # # https://mail.python.org/pipermail/numpy-discussion/2020-April/080566.html # # and the issue # # https://github.com/numpy/numpy-stubs/issues/41 # # for more context. np.float32([1.0, 0.0, 0.0]) # E: incompatible type np.complex64([]) # E: incompatible type np.complex64(1, 2) # E: Too many arguments # TODO: protocols (can't check for non-existent protocols w/ __getattr__) np.datetime64(0) # E: No overload variant class A: def __float__(self): return 1.0 np.int8(A()) # E: incompatible type np.int16(A()) # E: incompatible type np.int32(A()) # E: incompatible type np.int64(A()) # E: incompatible type np.uint8(A()) # E: incompatible type np.uint16(A()) # E: incompatible type np.uint32(A()) # E: incompatible type np.uint64(A()) # E: incompatible type np.void("test") # E: No overload variant np.void("test", dtype=None) # E: No overload variant np.generic(1) # E: Cannot instantiate abstract class np.number(1) # E: Cannot instantiate abstract class np.integer(1) # E: Cannot instantiate abstract class np.inexact(1) # E: Cannot instantiate abstract class np.character("test") # E: Cannot instantiate abstract class np.flexible(b"test") # E: Cannot instantiate abstract class np.float64(value=0.0) # E: Unexpected keyword argument np.int64(value=0) # E: Unexpected keyword argument np.uint64(value=0) # E: Unexpected keyword argument np.complex128(value=0.0j) # E: Unexpected keyword argument np.str_(value='bob') # E: No overload variant np.bytes_(value=b'test') # E: No overload variant np.void(value=b'test') # E: No overload variant np.bool_(value=True) # E: Unexpected keyword argument np.datetime64(value="2019") # E: No overload variant np.timedelta64(value=0) # E: Unexpected keyword argument np.bytes_(b"hello", encoding='utf-8') # E: No overload variant np.str_("hello", encoding='utf-8') # E: No overload variant f8.item(1) # E: incompatible type f8.item((0, 1)) # E: incompatible type f8.squeeze(axis=1) # E: incompatible type f8.squeeze(axis=(0, 1)) # E: incompatible type f8.transpose(1) # E: incompatible type def func(a: np.float32) -> None: ... func(f2) # E: incompatible type func(f8) # E: incompatible type round(c8) # E: No overload variant c8.__getnewargs__() # E: Invalid self argument f2.__getnewargs__() # E: Invalid self argument f2.hex() # E: Invalid self argument np.float16.fromhex("0x0.0p+0") # E: Invalid self argument f2.__trunc__() # E: Invalid self argument f2.__getformat__("float") # E: Invalid self argument PKIZYdata/fail/shape_base.pyinu[import numpy as np class DTypeLike: dtype: np.dtype[np.int_] dtype_like: DTypeLike np.expand_dims(dtype_like, (5, 10)) # E: No overload variant PKIZx6 ;;data/fail/stride_tricks.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] np.lib.stride_tricks.as_strided(AR_f8, shape=8) # E: No overload variant np.lib.stride_tricks.as_strided(AR_f8, strides=8) # E: No overload variant np.lib.stride_tricks.sliding_window_view(AR_f8, axis=(1,)) # E: No overload variant PKIZ:FZZdata/fail/testing.pyinu[import numpy as np import numpy.typing as npt AR_U: npt.NDArray[np.str_] def func() -> bool: ... np.testing.assert_(True, msg=1) # E: incompatible type np.testing.build_err_msg(1, "test") # E: incompatible type np.testing.assert_almost_equal(AR_U, AR_U) # E: incompatible type np.testing.assert_approx_equal([1, 2, 3], [1, 2, 3]) # E: incompatible type np.testing.assert_array_almost_equal(AR_U, AR_U) # E: incompatible type np.testing.assert_array_less(AR_U, AR_U) # E: incompatible type np.testing.assert_string_equal(b"a", b"a") # E: incompatible type np.testing.assert_raises(expected_exception=TypeError, callable=func) # E: No overload variant np.testing.assert_raises_regex(expected_exception=TypeError, expected_regex="T", callable=func) # E: No overload variant np.testing.assert_allclose(AR_U, AR_U) # E: incompatible type np.testing.assert_array_almost_equal_nulp(AR_U, AR_U) # E: incompatible type np.testing.assert_array_max_ulp(AR_U, AR_U) # E: incompatible type np.testing.assert_warns(warning_class=RuntimeWarning, func=func) # E: No overload variant np.testing.assert_no_warnings(func=func) # E: No overload variant np.testing.assert_no_warnings(func, None) # E: Too many arguments np.testing.assert_no_warnings(func, test=None) # E: Unexpected keyword argument np.testing.assert_no_gc_cycles(func=func) # E: No overload variant PKIZ2Hdata/fail/twodim_base.pyinu[from typing import Any, TypeVar import numpy as np import numpy.typing as npt def func1(ar: npt.NDArray[Any], a: int) -> npt.NDArray[np.str_]: pass def func2(ar: npt.NDArray[Any], a: float) -> float: pass AR_b: npt.NDArray[np.bool_] AR_m: npt.NDArray[np.timedelta64] AR_LIKE_b: list[bool] np.eye(10, M=20.0) # E: No overload variant np.eye(10, k=2.5, dtype=int) # E: No overload variant np.diag(AR_b, k=0.5) # E: No overload variant np.diagflat(AR_b, k=0.5) # E: No overload variant np.tri(10, M=20.0) # E: No overload variant np.tri(10, k=2.5, dtype=int) # E: No overload variant np.tril(AR_b, k=0.5) # E: No overload variant np.triu(AR_b, k=0.5) # E: No overload variant np.vander(AR_m) # E: incompatible type np.histogram2d(AR_m) # E: No overload variant np.mask_indices(10, func1) # E: incompatible type np.mask_indices(10, func2, 10.5) # E: incompatible type PKIZu.{{data/fail/type_check.pyinu[import numpy as np import numpy.typing as npt DTYPE_i8: np.dtype[np.int64] np.mintypecode(DTYPE_i8) # E: incompatible type np.iscomplexobj(DTYPE_i8) # E: incompatible type np.isrealobj(DTYPE_i8) # E: incompatible type np.typename(DTYPE_i8) # E: No overload variant np.typename("invalid") # E: No overload variant np.common_type(np.timedelta64()) # E: incompatible type PKIZ pdata/fail/ufunc_config.pyinu["""Typing tests for `numpy.core._ufunc_config`.""" import numpy as np def func1(a: str, b: int, c: float) -> None: ... def func2(a: str, *, b: int) -> None: ... class Write1: def write1(self, a: str) -> None: ... class Write2: def write(self, a: str, b: str) -> None: ... class Write3: def write(self, *, a: str) -> None: ... np.seterrcall(func1) # E: Argument 1 to "seterrcall" has incompatible type np.seterrcall(func2) # E: Argument 1 to "seterrcall" has incompatible type np.seterrcall(Write1()) # E: Argument 1 to "seterrcall" has incompatible type np.seterrcall(Write2()) # E: Argument 1 to "seterrcall" has incompatible type np.seterrcall(Write3()) # E: Argument 1 to "seterrcall" has incompatible type PKIZˑdata/fail/ufunclike.pyinu[from typing import Any import numpy as np AR_c: np.ndarray[Any, np.dtype[np.complex128]] AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] AR_M: np.ndarray[Any, np.dtype[np.datetime64]] AR_O: np.ndarray[Any, np.dtype[np.object_]] np.fix(AR_c) # E: incompatible type np.fix(AR_m) # E: incompatible type np.fix(AR_M) # E: incompatible type np.isposinf(AR_c) # E: incompatible type np.isposinf(AR_m) # E: incompatible type np.isposinf(AR_M) # E: incompatible type np.isposinf(AR_O) # E: incompatible type np.isneginf(AR_c) # E: incompatible type np.isneginf(AR_m) # E: incompatible type np.isneginf(AR_M) # E: incompatible type np.isneginf(AR_O) # E: incompatible type PKIZ}&CCdata/fail/ufuncs.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] np.sin.nin + "foo" # E: Unsupported operand types np.sin(1, foo="bar") # E: No overload variant np.abs(None) # E: No overload variant np.add(1, 1, 1) # E: No overload variant np.add(1, 1, axis=0) # E: No overload variant np.matmul(AR_f8, AR_f8, where=True) # E: No overload variant np.frexp(AR_f8, out=None) # E: No overload variant np.frexp(AR_f8, out=AR_f8) # E: No overload variant np.absolute.outer() # E: "None" not callable np.frexp.outer() # E: "None" not callable np.divmod.outer() # E: "None" not callable np.matmul.outer() # E: "None" not callable np.absolute.reduceat() # E: "None" not callable np.frexp.reduceat() # E: "None" not callable np.divmod.reduceat() # E: "None" not callable np.matmul.reduceat() # E: "None" not callable np.absolute.reduce() # E: "None" not callable np.frexp.reduce() # E: "None" not callable np.divmod.reduce() # E: "None" not callable np.matmul.reduce() # E: "None" not callable np.absolute.accumulate() # E: "None" not callable np.frexp.accumulate() # E: "None" not callable np.divmod.accumulate() # E: "None" not callable np.matmul.accumulate() # E: "None" not callable np.frexp.at() # E: "None" not callable np.divmod.at() # E: "None" not callable np.matmul.at() # E: "None" not callable PKIZ !data/fail/warnings_and_errors.pyinu[import numpy as np np.AxisError(1.0) # E: No overload variant np.AxisError(1, ndim=2.0) # E: No overload variant np.AxisError(2, msg_prefix=404) # E: No overload variant PKIZ#[[ data/misc/extended_precision.pyinu[import numpy as np reveal_type(np.uint128()) reveal_type(np.uint256()) reveal_type(np.int128()) reveal_type(np.int256()) reveal_type(np.float80()) reveal_type(np.float96()) reveal_type(np.float128()) reveal_type(np.float256()) reveal_type(np.complex160()) reveal_type(np.complex192()) reveal_type(np.complex256()) reveal_type(np.complex512()) PKIZ^; data/mypy.ininu[[mypy] plugins = numpy.typing.mypy_plugin show_absolute_path = True implicit_reexport = False [mypy-numpy] ignore_errors = True [mypy-numpy.*] ignore_errors = True PKIZ<&&2data/pass/__pycache__/ndarray_misc.cpython-311.pycnu[ bg UdZddlmZddlZddlmZmZddlZGddej Z ej dZ ej dggej Zd ed <ejd ej e Zejd ej e Zejd ej e Zej gdej Zd ed<ejde Ze eededeee eededeee eedeee eedeee ee d gej gdgdgdgej Zeeeeee dededdedeeddee dge dge dgee !e!e!e "e"e"e #e#e#ee $e$e$ee %e%e%de%de%ee &e&e&de&de&ee 'e'e'de'de'ee (e(e(de )e)e)de)de)ee *e*e*de*de+e,*ee -e-e-ee .de.de.de /e/e/de/de/e+ej0e 1e1e1de1de1ee 2de2de2dge2dee2dgee 3e3e3de3de3ee4dge5e6de6dee7e8de9e9eeej:ej ddej0fg2dZ:e:;dej0e<de<de=e=e>e>e?de?de,ej dej0e,ej dej@eAej dej0eAej dej@eBej dej0ejCej dejDdS)z Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods. More extensive tests are performed for the methods' function-based counterpart in `../from_numeric.py`. ) annotationsN)castAnyceZdZdS)SubClassN)__name__ __module__ __qualname__|/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/ndarray_misc.pyrrsr r)dtypez#np.ndarray[Any, np.dtype[np.int32]]Ar )r)rr)rrC)axisT)keepdims)out)r)|f g?1)E__doc__ __future__roperatortypingrrnumpynpndarrayrint32i4arrayr__annotations__emptyviewB0B1B2ronesDallanyargmaxargminargsortchoose_choicesclipcompressconj conjugatecumprodcumsummaxmeanmin newbyteorderprodptpastypeintroundrepeatstdfloat64sumtakevar argpartitiondiagonaldotnonzero searchsortedtracevoidsetfielditemravelflattenreshapestr_floatcomplexindexint64r r r r_s #"""""rz RXa[[)1A3%rx)H)H)HHHHH RXb!!!&&x00 RXd"(###((22 RXfBH%%%**844)1)))28)L)L)LLLLL BGAJJOOH1 t" 1 t"   aR  aR   2$ 28YYY 9995RX F F Fq q tQqbtQB QC A3 A3B         b   R1 t"  A21 t"  A21 t b  B !   ! 1 t"))BJ   1 t"  q s qbs1 t" s aaR q B tBGXRXabj(9':;;;@@CCDD b"*q q      !  ! HBHS ###$$$HBHS   !!!hbhs"*%%%&&&hbhs"'"""###BJ'''(((xrx***+++++r PKIZF 4 40data/pass/__pycache__/arithmetic.cpython-311.pycnu[ bgUddlmZddlmZddlZddlZejdZej dZ ej dZ ej dZejdZejdZejdZejdZejddZejddZejdZedZedZ e!dZ"e#dZ$GddZ%ej&dgZ'd e(d <ej&dgej Z)d e(d <ej&dgZ*de(d<ej&dgZ+de(d<ej&dgZ,de(d<ej&ejddgZ-de(d<ej&ejddgZ.de(d<ej&e%gZ/de(d<dgZ0ejdgZ1dgZ2dgZ3dgZ4ejddgZ5ejddgZ6e%gZ7e'e1z e'e2z e'e3z e'e4z e'e5z e'e7z e1e'z e2e'z e3e'z e4e'z e5e'z e6e'z e7e'z e)e0z e)e1z e)e2z e)e3z e)e4z e)e5z e)e7z e0e)z e1e)z e2e)z e3e)z e4e)z e5e)z e6e)z e7e)z e*e0z e*e1z e*e2z e*e3z e*e4z e*e5z e*e7z e0e*z e1e*z e2e*z e3e*z e4e*z e5e*z e6e*z e7e*z e+e0z e+e1z e+e2z e+e3z e+e4z e+e7z e0e+z e1e+z e2e+z e3e+z e4e+z e7e+z e,e0z e,e1z e,e2z e,e3z e,e4z e,e7z e0e,z e1e,z e2e,z e3e,z e4e,z e7e,z e-e0z e-e1z e-e2z e-e5z e0e-z e1e-z e2e-z e5e-z e6e-z e.e0z e.e1z e.e2z e.e5z e.e6z e6e.z e/e0z e/e1z e/e2z e/e3z e/e4z e/e7z e0e/z e1e/z e2e/z e3e/z e4e/z e7e/z e)e'z Z)e)e)z Z)e)dz Z)e'e0ze'e1ze'e2ze'e3ze'e7ze0e'ze1e'ze2e'ze3e'ze7e'ze)e0ze)e1ze)e2ze)e3ze)e7ze0e)ze1e)ze2e)ze3e)ze5e)ze7e)ze*e0ze*e1ze*e2ze*e3ze*e7ze0e*ze1e*ze2e*ze3e*ze5e*ze7e*ze+e0ze+e1ze+e2ze+e3ze+e7ze0e+ze1e+ze2e+ze3e+ze5e+ze7e+ze-e1ze-e2ze-e3ze-e5ze5e-ze/e0ze/e1ze/e2ze/e3ze/e7ze0e/ze1e/ze2e/ze3e/ze7e/ze'e0zZ'e)e0zZ)e)e1zZ)e*e0zZ*e*e1zZ*e*e2zZ*e+e0zZ+e+e1zZ+e+e2zZ+e+e3zZ+e,e0zZ,e,e1zZ,e,e2zZ,e,e3zZ,e,e4zZ,e-e0zZ-e-e1zZ-e-e2zZ-e-e3zZ-e/e0zZ/e/e1zZ/e/e2zZ/e/e3zZ/e/e4zZ/e/e7zZ/e)e0zZ)e)e1zZ)e*e0zZ*e*e1zZ*e*e2zZ*e+e0zZ+e+e1zZ+e+e2zZ+e+e3zZ+e,e0zZ,e,e1zZ,e,e2zZ,e,e3zZ,e,e4zZ,e/e0zZ/e/e1zZ/e/e2zZ/e/e3zZ/e/e4zZ/e/e7zZ/e e e e e e ej8e95e e dddn #1swxYwYe e+ e e e e e e e e e e+ e:ee:ee:e e:ee:e e:ee:ee:ee:ee:ee:e+eezee$zeezee zeez ee$z eez ee z eezee$zeezee zeez ee$z eez ee z ee"z eez ee z eez eezeezeez eez ee$z ee z eez eez eez ee"z ee z eez ee z eez eez eez eez e$ez e ez eez eez eez e"ez e ez eez e ez eez eez eezee zee zeezeezeezeezeezee zee"zee$zee+zeeze eze ezeezeezeezeezeeze eze"eze$eze+ezeezee zee zeezeezeezeezeezee zee"zee$zee+zeeze eze ezeezeezeezeezeeze eze"eze$eze+eze e ze e ze eze eze eze eze e ze e"ze e$ze e+ze e ze e zee zee zee zee ze e ze"e ze$e ze+e zee zee zeezeezeezeezee zee"zee$zee+ze eze ezeezeezeezeeze eze"eze$eze+eze e ze eze eze eze eze eze e ze e"ze e$ze e+zeezeezeezeezeezee zee"zee$zee+ze e zee zee zee zee zee ze e ze"e ze$e ze+e zeezeezeezeezeeze eze"eze$eze+ezee zeezee$zeezeezee+zee zeezeezeezee$zeezeezee+ze ezeeze$ezeezeeze+eze ezeezeezeezeezeeze$eze+ezdS)) annotations)AnyNDcVeZdZddZddZddZddZdd Zdd Zdd Z dd Z dd Z dS)Objectreturn%np.ndarray[Any, np.dtype[np.object_]]cFtjdt}||d<|S)Ndtype)npemptyobject)selfrets z/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/arithmetic.py __array__zObject.__array__s$hr(((B valuerc|SNr rrs r__sub__zObject.__sub__" rc|Srr rs r__rsub__zObject.__rsub__%rrc|Srr rs r __floordiv__zObject.__floordiv__(rrc|Srr rs r __rfloordiv__zObject.__rfloordiv__+rrc|Srr rs r__mul__zObject.__mul__.rrc|Srr rs r__rmul__zObject.__rmul__1rrc|Srr rs r__pow__zObject.__pow__4rrc|Srr rs r__rpow__zObject.__rpow__7rrN)r r )rrr r) __name__ __module__ __qualname__rrrr r"r$r&r(r*r rrrrs rrTz#np.ndarray[Any, np.dtype[np.bool_]]AR_br z$np.ndarray[Any, np.dtype[np.uint32]]AR_uz#np.ndarray[Any, np.dtype[np.int64]]AR_ig?z%np.ndarray[Any, np.dtype[np.float64]]AR_fy?z(np.ndarray[Any, np.dtype[np.complex128]]AR_cz)np.ndarray[Any, np.dtype[np.timedelta64]]AR_mz(np.ndarray[Any, np.dtype[np.datetime64]]AR_Mr AR_O); __future__rtypingrnumpyrpytest complex128c16float64f8int64i8uint64u8 complex64c8float32f4int32i4uint32u4 datetime64dt timedelta64tdbool_b_boolbcomplexcfloatfintirarrayr.__annotations__r/r0r1r2r3r4r5 AR_LIKE_b AR_LIKE_u AR_LIKE_i AR_LIKE_f AR_LIKE_c AR_LIKE_m AR_LIKE_M AR_LIKE_OwarnsRuntimeWarningabsr rrres""""""" bmARZ]] RXa[[RYq\\R\!__RZ]] RXa[[RYq\\R]1cR^As RXa[[DGG GAJJ E!HHCFF>-5BHdV,<,<<<<<-5RXqc-K-K-KKKKK,4BHaSMM9999.6bhuoo====192$????2:"(NBN1cr5s  RX1v1vrx{{   1   Q 1a 61  3 47d?? $ $F 3 3 3s #( #(B #( ### #(B%%% #(4 ((( # ' % % %s  %h % """ %h%%% %t  %hd+++ %d   D   bh")RY61+6{32=III w u w""" uQ'''  D $  D$ $d ### D$ $d .....s"BG  GGPKIZu662data/pass/__pycache__/numerictypes.cpython-311.pycnu[ bgddlZejdejeejeejdejeejedejeejejej e ejej e ejej e e fej de ej ejdgejdgejdejejej ejejdejeeje ejdejejeje ejdejejejejdejdejd ejd ejd ejd ejd dS)NS8)defaultint64S1i8 CharacterComplexAll)numpynpmaximum_sctypeobjectissctype obj2sctypelistbytes_ issubclass_int32intfloat64float issubsctypearray issubdtypefloat32 sctype2charcastrnbytes ScalarType typecodes|/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/numerictypes.pyr(s'$&  F  D  d  dD!!!!  dBI&&&&rxrz5!!!rzC<(((wxrx}}hbhsmm,,,  dBI  bj"*%%%tt   # $ "(  a a a b [ Y Ur&PKIZF8data/pass/__pycache__/array_constructors.cpython-311.pycnu[ bgs  ddlZddlmZddlZGddZGddejZdeded ed efd Z ej d Z ej d gZ e eZej d gd ggeZd gZejeejegej d e ej d dej d dej d dej d dej d dej d eddddeje ejeejeeje ejeejee ejeeje ejeejeeje ejeejeeje ejeejee ejedejedejedgejeddhejeddgejedejedejeejddejdgd ejgd dejd!dejddd"#ejddd$ejddd%ejd!d&d%ejdde ejdd gddge'ejddd(ejddd(ejddd)d&gd*ejd deje ejeejeejeej eje ejeejeejeej ej e ej eej eej eej ej!e e ej!ee ej!ee ej!ee ej ej"d ej"gd+ej#d e ej#gd+e ej$gd,ej$gd,d-ej%e d.ej&d"ej'eej'e ej'eeej'ee ej'e e ej(eej)eej*eegej*ee gej*e e gej+eegej,eegej,eegd'ej,eege/ej-eegeeggej-e dS)0N)AnyceZdZdefdZdS)IndexreturncdS)Nr)selfs /builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/array_constructors.py __index__zIndex.__index__sqN)__name__ __module__ __qualname__intr rr r rrs/3r rceZdZdS)SubClassN)r rrrr r rr sDr rijkwargsrc tS)N)B)rrrs r funcrs Hr )dtypeF)copyF)orderT)subok)ndminC)rrrr ) requirementsE ENSUREARRAYOWNDATAWAg?)rrr"y )num)endpoint)retstepy@)axis)basey?)r.r*)rrr)rr"r)sparse)r)out).systypingrnumpynprndarrayrrrint64i8arrayr(viewrrB_stackr!floatstrasarray asanyarrayascontiguousarrayasfortranarrayrequirelinspaceboollogspace geomspace zeros_like ones_like empty_like full_likeonesfullindices fromfunctionidentity atleast_1d atleast_2d atleast_3dvstackhstackstackblockrr r rWsl       rz    C C 3 8    RXa[[ BHaSMMFF8 "(QC!:   # #H - -C  5577  EEGG9%#$$!Cd#U!<<<<  1  1  1  a  a  as  aQQQ!!!  1  1  1C  14  13  1M?++++  1C:&&&&  1C+,,,,  13  13  1  Aq  C  IIIq  B  Aqb  Aq4  Aq$  BD!!!!  Aq  QFQF))))  Aqq  Aqq  AqBxQ''''  Q  a  a  a  arx  Q  Q  Q  Qbh  a  a  a  arx  Q  Q  Q  Q"(####  2 2  999  999T""""f  B  a  a  a  a  a  a  a  1a&  1a&  1a&  1a&!Q!Qa!QW1a&1a&  r PKIZے] ] 0data/pass/__pycache__/array_like.cpython-311.pycnu[ bgUddlmZddlmZddlZddlmZmZdZ de d<dZ de d <d Z de d <d Z de d <ejdZde d<ejdZde d<ejdZde d<ejgdZde d<gdZde d<dZde d<dZde d<edZde d<GddZeZde d<ejdZde d<eejdZde d<eeZ de d <e e d!e!d"DZ"d#e d$<eje"dS)%) annotations)AnyN) ArrayLike_SupportsArrayTrx1x2g?x3y??x4x5x6x7r x8x9x10foox11sfoox12ceZdZdddZdS) ANdtypeNone | np.dtype[Any]return np.ndarrayc.tjgdS)Nr)nparray)selfrs z/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/array_like.py __array__z A.__array__sx """N)rrrr)__name__ __module__ __qualname__r$r%r#rrs-#######r%rx13rscalarr!ac#K|]}|VdSr&r*).0is r# r1(s"11!A111111r% robject_array_scalar)# __future__rtypingrnumpyr numpy._typingrrr__annotations__r r r int8r float64r complex128rr!rrrr memoryviewrrr+int64r,r$r-ranger3r*r%r#r?sg"""""""33333333  1  a   ###### F############## !!$$$$  ####ACC  21uuRyy1111111 r%PKIZbb,data/pass/__pycache__/random.cpython-311.pycnu[ bg UddlmZddlmZddlZdZdZejgdej Z de d<gdZ d e d <ej dZd e d <ej dZd e d<ej dZde d<ej dZde d<ej dZde d<ej ej eej eej e ej e ej eej eej eej eej eej eej eej e ej e ej eej eej e ej e ej eej eej eej e ej e ej eej eej eej e ej e ej eej eej eej e ej e ej eej eZde d<edededdeddeddeddedejedejej Zde d<ejdgZd e d!<ejd"gZ d e d#<ejd$gZ!d e d%<ejd&gZ"d e d'<ejdgej#Z$d(e d)<ejd*gej#Z%d(e d+<dgZ&d,e d-<d"gZ'd,e d.<d$gZ(d,e d/<d&gZ)d,e d0<dgZ*d e d1<d*gZ+d e d2<d3d4gd4dgdd5gd5d6ggZ,d7e d8<eje,Z-d e d9<ej.d3ej/Z0d:e d;<ej.d3Z1d e d<<e2e2ej/e2d=e2d>e2ej3e2d?e2d3?e2d3ej/@e2d3dA@e2d3d=e0Be2ej/e0Ce2d3ej3@e2d3dD@e2d3dE@e2e1Fe2d3dD@e2d3dDe1Be e ej/e d=e d>e ej3e d?e d3?e d3ej/@e d3dA@e d3d=e0Be ej/e0Ce d3ej3@e d3dD@e d3dE@e e1Fe d3dD@e d3dDe1Be4e4d?e4d3?e5e5dGHe5ej/e5d=e5d>e5ej3e5d?e5ddGIe5d3dGIe5d3ej/@e5d3dAdGJe5d3d=e0Be5ej/e0Ce5d3ej3dGJe5d3dD@e5d3dE@e5e1Fe5d3dD@e5d3dDe1Be6d&e6d&d?e6d&d3?e6e"e6e"d3?e6e)e6e)d3?e7d"e7d"d?e7d"d3?e7e e7e d3?e7e'e7e'd3?e8d"e8d"d?e8d"d3?e8e e8e d3?e8e'e8e'd3?e9d"e9d"d?e9d"d3?e9e e9e d3?e9e'e9e'd3?e:d"e:d"d?e:d"d3?e:e e:e d3?e:e'e:e'd3?e;d"e;d"d?e;d"d3?e;e e;e d3?e;e'e;e'd3?e<d"e<d"d?e<d"d3?e<e e<e d3?e<e'e<e'd3?e=d"e=d"d?e=d"d3?e=e e=e d3?e=e'e=e'd3?e>d"e>d"d?e>d"d3?e>e e>e d3?e>e'e>e'd3?e?d"e?d"d?e?d"d3?e?e e?e d3?e?e'e?e'd3?e@d"e@d"d?e@d"d3?e@e e@e d3?e@e'e@e'd3?eAd"eAd"d?eAd"d=eAd"dd=@eAd"d3?eAe eAe dAeAd"d3d=e0BeAe ej/e0CeAe d3?eAe'eAe'd3?eAd"e1FeAe'e1FeAe'd3?eAe'd3e1ej3KeBd"d"eBd"d"d?eBd"d"d3?eBe d"eBd"e eBe d"d3?eBd"e d3?eBe'd"eBd"e'eBe e eBe'e'eBe e d3?eBe'e'd3?eCd"d"eCd"d"d?eCd"d"d3?eCe d"eCd"e eCe d"d3?eCd"e d3?eCe'd"eCd"e'eCe e eCe'e'eCe e d3?eCe'e'd3?eDd"d"eDd"d"d?eDd"d"d3?eDe d"eDd"e eDe d"d3?eDd"e d3?eDe'd"eDd"e'eDe e eDe'e'eDe e d3?eDe'e'd3?eEd"d"eEd"d"d?eEd"d"d3?eEe d"eEd"e eEe d"d3?eEd"e d3?eEe'd"eEd"e'eEe e eEe'e'eEe e d3?eEe'e'd3?eFd"d"eFd"d"d?eFd"d"d3?eFe d"eFd"e eFe d"d3?eFd"e d3?eFe'd"eFd"e'eFe e eFe'e'eFe e d3?eFe'e'd3?eGd"d"eGd"d"d?eGd"d"d3?eGe d"eGd"e eGe d"d3?eGd"e d3?eGe'd"eGd"e'eGe e eGe'e'eGe e d3?eGe'e'd3?eHd"d"eHd"d"d?eHd"d"d3?eHe d"eHd"e eHe d"d3?eHd"e d3?eHe'd"eHd"e'eHe e eHe'e'eHe e d3?eHe'e'd3?eId"d"eId"d"d?eId"d"d3?eIe d"eId"e eIe d"d3?eId"e d3?eIe'd"eId"e'eIe e eIe'e'eIe e d3?eIe'e'd3?eJd"d"eJd"d"d?eJd"d"d3?eJe d"eJd"e eJe d"d3?eJd"e d3?eJe'd"eJd"e'eJe e eJe'e'eJe e d3?eJe'e'd3?eKd"d"eKd"d"d?eKd"d"d3?eKe d"eKd"e eKe d"d3?eKd"e d3?eKe'd"eKd"e'eKe e eKe'e'eKe e d3?eKe'e'd3?eLd"d"eLd"d"d?eLd"d"d3?eLe d"eLd"e eLe d"d3?eLd"e d3?eLe'd"eLd"e'eLe e eLe'e'eLe e d3?eLe'e'd3?eMd"d"eMd"d"d?eMd"d"d3?eMe d"eMd"e eMe d"d3?eMd"e d3?eMe'd"eMd"e'eMe e eMe'e'eMe e d3?eMe'e'd3?eNdd"d$eNdd"d$d?eNdd"d$d3?eNed"d$eNde d$eNed"e(d3?eNde d$d3?eNe&d"e!eNd"e'd$eNee d$eNe&e'd$eNee e!d3?eNe&e'e(d3?eOdd"d$eOdd"d$d?eOdd"d$d3?eOed"d$eOde d$eOed"e(d3?eOde d$d3?eOe&d"e!eOd"e'd$eOee d$eOe&e'd$eOee e!d3?eOe&e'e(d3?ePdd"ePdd"d?ePdd"d3?ePe$d"ePde ePe$d"d3?ePde d3?ePe*d"ePde'ePe$e ePe*e'ePe$e d3?ePe*e'd3?eQdd"eQdd"d?eQdd"d3?eQe$d"eQde eQe$d"d3?eQde d3?eQe*d"eQde'eQe$e eQe*e'eQe$e d3?eQe*e'd3?eRd*d*deRd*d*dd?eRd*d*dd3?eRe%d*deRd*e%deRe%d*e*d3?eRd*e%dd3?eRe+d*e$eRd*e+deRe%e%deRe+e+deRe%e%e$d3?eRe+e+e*d3?ejdLgej ZSde dM<eTddLeTdLeTdLgeTddLgejdgejUZVdNe dO<dgZWd e dP<ejd3gejUZXdNe dQ<ejd3gejUZYdNe dR<eTd4eZeTdd4eZeTd3eZdSTeTdd3eZdSTeTeWd3eZdSTeTeXeZeTeVeXeZeTdeXeZeTeYeZdSTeTeVeYeZdSTeTdeYeZdSTeTd4ejUeTdd4ejUeTd3ejUdSTeTdd3ejUdSTeTeWd3ejUdSTeTeXejUeTeVeXejUeTdeXejUeTeYejUdSTeTeVeYejUdSTeTdeYejUdSTejdgej[Z\dUe dV<dgZ]d e dW<ejdXgej[Z^dUe dY<ejdXgej[Z_dUe dZ<eTd[d\eTdd[d\eTdXd\dSTeTddXd\dSTeTe]dXd\dSTeTe^d\eTe\e^d\eTde^d\eTe_d\dSTeTe\e_d\dSTeTde_d\dSTeTd[d]eTdd[d]eTdXd]dSTeTddXd]dSTeTe]dXd]dSTeTe^d]eTe\e^d]eTde^d]eTe_d]dSTeTe\e_d]dSTeTde_d]dSTeTd[ej[eTdd[ej[eTdXej[dSTeTddXej[dSTeTe]dXej[dSTeTe^ej[eTe\e^ej[eTde^ej[eTe_ej[dSTeTe\e_ej[dSTeTde_ej[dSTejdgej`Zad^e d_<dgZbd e d`<ejdagej`Zcd^e db<ejdagej`Zdd^e dc<eTdddeeTddddeeTdadedSTeTddadedSTeTebdadedSTeTecdeeTeaecdeeTdecdeeTeddedSTeTeaeddedSTeTdeddedSTeTdddfeTddddfeTdadfdSTeTddadfdSTeTebdadfdSTeTecdfeTeaecdfeTdecdfeTeddfdSTeTeaeddfdSTeTdeddfdSTeTddej`eTdddej`eTdaej`dSTeTddaej`dSTeTebdaej`dSTeTecej`eTeaecej`eTdecej`eTedej`dSTeTeaedej`dSTeTdedej`dSTejdgejZedge dh<dgZfd e di<ejdjgejZgdge dk<ejdjgejZhdge dl<eTdmdeTddmdeTdjddSTeTddjddSTeTefdjddSTeTegdeTeeegdeTdegdeTehddSTeTeeehddSTeTdehddSTeTdmdeTddmdeTdjddSTeTddjddSTeTefdjddSTeTegdeTeeegdeTdegdeTehddSTeTeeehddSTeTdehddSTeTdmejeTddmejeTdjejdSTeTddjejdSTeTefdjejdSTeTegejeTeeegejeTdegejeTehejdSTeTeeehejdSTeTdehejdSTejdgejZidne do<dgZjd e dp<ejdqgejZkdne dr<ejdqgejZldne ds<eTdtdeTddtdeTdqddSTeTddqddSTeTejdqddSTeTekdeTeiekdeTdekdeTelddSTeTeielddSTeTdelddSTeTdtdeTddtdeTdqddSTeTddqddSTeTejdqddSTeTekdeTeiekdeTdekdeTelddSTeTeielddSTeTdelddSTeTdtejeTddtejeTdqejdSTeTddqejdSTeTejdqejdSTeTekejeTeiekejeTdekejeTelejdSTeTeielejdSTeTdelejdSTejdugejmZndve dw<dugZod e dx<ejdygejmZpdve dz<ejdygejmZqdve d{<eTd|d}eTdud|d}eTdyd}dSTeTdudyd}dSTeTeodyd}dSTeTepd}eTenepd}eTduepd}eTeqd}dSTeTeneqd}dSTeTdueqd}dSTeTd|d~eTdud|d~eTdyd~dSTeTdudyd~dSTeTeodyd~dSTeTepd~eTenepd~eTduepd~eTeqd~dSTeTeneqd~dSTeTdueqd~dSTeTd|ejmeTdud|ejmeTdyejmdSTeTdudyejmdSTeTeodyejmdSTeTepejmeTenepejmeTduepejmeTeqejmdSTeTeneqejmdSTeTdueqejmdSTejdgejrZsde d<dgZtd e d<ejdgejrZude d<ejdgejrZvde d<eTddeTdddeTdddSTeTddddSTeTetdddSTeTeudeTeseudeTdeudeTevddSTeTesevddSTeTdevddSTeTddeTdddeTdddSTeTddddSTeTetdddSTeTeudeTeseudeTdeudeTevddSTeTesevddSTeTdevddSTeTdejreTddejreTdejrdSTeTddejrdSTeTetdejrdSTeTeuejreTeseuejreTdeuejreTevejrdSTeTesevejrdSTeTdevejrdSTejdgejwZxde d<dgZyd e d<ejdgejwZzde d<ejdgejwZ{de d<eTddeTdddeTdddSTeTddddSTeTeydddSTeTezdeTexezdeTdezdeTe{ddSTeTexe{ddSTeTde{ddSTeTddeTdddeTdddSTeTddddSTeTeydddSTeTezdeTexezdeTdezdeTe{ddSTeTexe{ddSTeTde{ddSTeTdejweTddejweTdejwdSTeTddejwdSTeTeydejwdSTeTezejweTexezejweTdezejweTe{ejwdSTeTexe{ejwdSTeTde{ejwdSTejdgej Z|de d<dgZ}d e d<ejdgej Z~de d<ejdgej Zde d<eTddeTdddeTdddSTeTddddSTeTe}dddSTeTe~deTe|e~deTde~deTeddSTeTe|eddSTeTdeddSTeTddeTdddeTdddSTeTddddSTeTe}dddSTeTe~deTe|e~deTde~deTeddSTeTe|eddSTeTdeddSTeTdej eTddej eTdej dSTeTddej dSTeTe}dej dSTeTe~ej eTe|e~ej eTde~ej eTeej dSTeTe|eej dSTeTdeej dSTejed4ededdedddSedddgdzedddgdzdegdegddegdddgd5zegdddSegdddejgded"d"geejd"d"geejd"d"gd?ed*dgdzed*ejd"d"ged*dgdzd4?edgd*ggdgdzd?eejdgd*ggejd"d"gd?egdd4eejgdd4eejgdd4d5?eejgdd4d?egdd4dHeejgdd4dHedgdggedgejdggeejdgdggedgejdggedegdeejgdee-d3ee-ee,ee-d3ee-e-Fee,e-Fee,e-Fee-d3e-eejdegdee-d3eede d<eZeeej Zde d<e2e2d?e2d3?e e d?e d3?e4e4d?e4d3?e5e5d?e5d3?e6d&e6d&d?e6d&d3?e6e"e6e"d3?e6e)e6e)d3?e7d"e7d"d?e7d"d3?e7e e7e d3?e7e'e7e'd3?e8d"e8d"d?e8d"d3?e8e e8e d3?e8e'e8e'd3?e9d"e9d"d?e9d"d3?e9e e9e d3?e9e'e9e'd3?e:d"e:d"d?e:d"d3?e:e e:e d3?e:e'e:e'd3?e;d"e;d"d?e;d"d3?e;e e;e d3?e;e'e;e'd3?e<d"e<d"d?e<d"d3?e<e e<e d3?e<e'e<e'd3?e=d"e=d"d?e=d"d3?e=e e=e d3?e=e'e=e'd3?e>d"e>d"d?e>d"d3?e>e e>e d3?e>e'e>e'd3?e?d"e?d"d?e?d"d3?e?e e?e d3?e?e'e?e'd3?e@d"e@d"d?e@d"d3?e@e e@e d3?e@e'e@e'd3?eAd"eAd"d?eAd"d3?eAe eAe d3?eAe'eAe'd3?eAe'd3?eBd"d"eBd"d"d?eBd"d"d3?eBe d"eBd"e eBe d"d3?eBd"e d3?eBe'd"eBd"e'eBe e eBe'e'eBe e d3?eBe'e'd3?eCd"d"eCd"d"d?eCd"d"d3?eCe d"eCd"e eCe d"d3?eCd"e d3?eCe'd"eCd"e'eCe e eCe'e'eCe e d3?eCe'e'd3?eDd"d"eDd"d"d?eDd"d"d3?eDe d"eDd"e eDe d"d3?eDd"e d3?eDe'd"eDd"e'eDe e eDe'e'eDe e d3?eDe'e'd3?eEd"d"eEd"d"d?eEd"d"d3?eEe d"eEd"e eEe d"d3?eEd"e d3?eEe'd"eEd"e'eEe e eEe'e'eEe e d3?eEe'e'd3?eFd"d"eFd"d"d?eFd"d"d3?eFe d"eFd"e eFe d"d3?eFd"e d3?eFe'd"eFd"e'eFe e eFe'e'eFe e d3?eFe'e'd3?eGd"d"eGd"d"d?eGd"d"d3?eGe d"eGd"e eGe d"d3?eGd"e d3?eGe'd"eGd"e'eGe e eGe'e'eGe e d3?eGe'e'd3?eHd"d"eHd"d"d?eHd"d"d3?eHe d"eHd"e eHe d"d3?eHd"e d3?eHe'd"eHd"e'eHe e eHe'e'eHe e d3?eHe'e'd3?eId"d"eId"d"d?eId"d"d3?eIe d"eId"e eIe d"d3?eId"e d3?eIe'd"eId"e'eIe e eIe'e'eIe e d3?eIe'e'd3?eJd"d"eJd"d"d?eJd"d"d3?eJe d"eJd"e eJe d"d3?eJd"e d3?eJe'd"eJd"e'eJe e eJe'e'eJe e d3?eJe'e'd3?eKd"d"eKd"d"d?eKd"d"d3?eKe d"eKd"e eKe d"d3?eKd"e d3?eKe'd"eKd"e'eKe e eKe'e'eKe e d3?eKe'e'd3?eLd"d"eLd"d"d?eLd"d"d3?eLe d"eLd"e eLe d"d3?eLd"e d3?eLe'd"eLd"e'eLe e eLe'e'eLe e d3?eLe'e'd3?eMd"d"eMd"d"d?eMd"d"d3?eMe d"eMd"e eMe d"d3?eMd"e d3?eMe'd"eMd"e'eMe e eMe'e'eMe e d3?eMe'e'd3?eNdd"d$eNdd"d$d?eNdd"d$d3?eNed"d$eNde d$eNed"e(d3?eNde d$d3?eNe&d"e!eNd"e'd$eNee d$eNe&e'd$eNee e!d3?eNe&e'e(d3?eOdd"d$eOdd"d$d?eOdd"d$d3?eOed"d$eOde d$eOed"e(d3?eOde d$d3?eOe&d"e!eOd"e'd$eOee d$eOe&e'd$eOee e!d3?eOe&e'e(d3?ePdd"ePdd"d?ePdd"d3?ePe$d"ePde ePe$d"d3?ePde d3?ePe*d"ePde'ePe$e ePe*e'ePe$e d3?ePe*e'd3?eQdd"eQdd"d?eQdd"d3?eQe$d"eQde eQe$d"d3?eQde d3?eQe*d"eQde'eQe$e eQe*e'eQe$e d3?eQe*e'd3?eRd*d*deRd*d*dd?eRd*d*dd3?eRe%d*deRd*e%deRe%d*e*d3?eRd*e%dd3?eRe+d*e$eRd*e+deRe%e%deRe+e+deRe%e%e$d3?eRe+e+e*d3?eddLedLedLgeddLged4eZedd4eZeeXeZeeVeXeZedeXeZed4ejUedd4ejUeeXejUeeVeXejUedeXejUed[d\edd[d\ee^d\ee\e^d\ede^d\ed[d]edd[d]ee^d]ee\e^d]ede^d]ed[ej[edd[ej[ee^ej[ee\e^ej[ede^ej[edddeeddddeeecdeeeaecdeedecdeedddfeddddfeecdfeeaecdfedecdfeddej`edddej`eecej`eeaecej`edecej`edmdeddmdeegdeeeegdedegdedmdeddmdeegdeeeegdedegdedmejeddmejeegejeeeegejedegejedtdeddtdeekdeeiekdedekdedtdeddtdeekdeeiekdedekdedtejeddtejeekejeeiekejedekejed|d}edud|d}eepd}eenepd}eduepd}ed|d~edud|d~eepd~eenepd~eduepd~ed|ejmedud|ejmeepejmeenepejmeduepejmeddedddeeudeeseudedeudeddedddeeudeeseudedeudedejreddejreeuejreeseuejredeuejreddedddeezdeexezdedezdeddedddeezdeexezdedezdedejweddejweezejweexezejwedezejweddedddee~dee|e~dede~deddedddee~dee|e~dede~dedej eddej ee~ej ee|e~ej ede~ej ejZde d<ed4ededdedddSedddgdzedddgdzdegdegddegdddgd5zegdddSegdddejgded"d"geejd"d"geejd"d"gd?ed*dgdzed*ejd"d"ged*dgdzd4?edgdggedgejdggeejdgdggedgejdggedegdeejgdee-eejdegdee-ej eej dej gdeeeZeeeed3edd3geZedSZeeeed3ed3d4eed3ed3d4eed3ed?eed3edej eej dS)) annotations)AnyNlGW~ H~s))dtypez#np.ndarray[Any, np.dtype[np.int64]]SEED_ARRz list[int] SEED_ARRLIKEznp.random.SeedSequence SEED_SEED_SEQznp.random.MT19937 SEED_MT19937znp.random.PCG64 SEED_PCG64znp.random.Philox SEED_PHILOXznp.random.SFC64 SEED_SFC64z$np.random.bit_generator.SeedSequenceseed_seq ru4uint32u8uint64znp.random.Generatordef_geng?z%np.ndarray[Any, np.dtype[np.float64]] D_arr_0p1? D_arr_0p5g? D_arr_0p9g? D_arr_1p5z"np.ndarray[Any, np.dtype[np.int_]]I_arr_10I_arr_20z list[float]D_arr_like_0p1D_arr_like_0p5D_arr_like_0p9D_arr_like_1p5 I_arr_like_10 I_arr_like_20rrrgffffff@zlist[list[float]] D_2D_likeD_2Dz%np.ndarray[Any, np.dtype[np.float32]]S_outD_outfloat32double)size)r,r f4)r,r out)r r.float64f8)r.inv)method)r,r2)r,r r2)r,r.r d I_int64_100z#np.ndarray[Any, np.dtype[np.bool_]] I_bool_lowI_bool_low_likeI_bool_high_openI_bool_high_closedT)r endpointz#np.ndarray[Any, np.dtype[np.uint8]]I_u1_low I_u1_low_likeI_u1_high_openI_u1_high_closedu1uint8z$np.ndarray[Any, np.dtype[np.uint16]]I_u2_low I_u2_low_likeiI_u2_high_openI_u2_high_closediu2uint16z$np.ndarray[Any, np.dtype[np.uint32]]I_u4_low I_u4_low_likelI_u4_high_openI_u4_high_closedlz$np.ndarray[Any, np.dtype[np.uint64]]I_u8_low I_u8_low_likelI_u8_high_openI_u8_high_closedliz"np.ndarray[Any, np.dtype[np.int8]]I_i1_low I_i1_low_likeI_i1_high_openI_i1_high_closedi1int8iz#np.ndarray[Any, np.dtype[np.int16]]I_i2_low I_i2_low_likeiI_i2_high_openI_i2_high_closedii2int16iz#np.ndarray[Any, np.dtype[np.int32]]I_i4_low I_i4_low_likeiI_i4_high_openI_i4_high_closedli4int32lI_i8_low I_i8_low_likelI_i8_high_openI_i8_high_closedli8int64)replaceg?)pF)rlrk)poohrabbitpiglet Christopher?)?rrrrq)rkrlgUUUUUU?)rr)rrj)rrtcount marginalsgg?)axis)rwr.)rrrrrjzdict[str, Any] def_gen_stateznp.random.RandomState random_stznp.random.BitGeneratorbg)rrr)legacy)rr)r) __future__rtypingrnumpynp SEED_NONESEED_INTarrayrir __annotations__r random SeedSequencer MT19937r PCG64rPhiloxrSFC64r default_rngrspawngenerate_staterrrrrrrint_rrr r!r"r#r$r%r&r'emptyr*r(r)standard_normalr/standard_cauchystandard_exponentialzipfweibull standard_tpoissonpowerpareto chisquare exponential geometric logseriesrayleighstandard_gammavonmiseswalduniformbetafgammagumbellaplacelogistic lognormalnoncentral_chisquarenormal triangular noncentral_fbinomialnegative_binomialhypergeometricr4integersbool_r5r6r7r8boolrAr:r;r=r>rGrBrCrDrErHrIrJrKrLrMrNrOrWrPrQrSrTr]rXrYrZr[rcr^r_r`rardrerfrg bit_generatorbyteschoice dirichlet multinomialmultivariate_hypergeometricmultivariate_normal permutationpermutedshufflearange__str____repr__ __getstate__rx __setstate__ RandomStateryrandint_bit_generatorrzrandom_st_stateseed get_staterandom_st_get_staterandom_st_get_state_legacy set_staterandrandn random_sampletomaxintset_bit_generatorget_bit_generatorv/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/random.pyrs"""""""  *08RX0V0V0VVVVV&,, &&&&(* (>(>q(A(A AAAA"$)"3"3A"6"6 6666 iooa00 0000 " 0 0 3 3 3333 iooa00 0000  i  h h l### m$$$ l### j!!! k""" j!!! y!!! x  x  |$$$ ) ( ( , -                      131G1G 1R1RRRRRr4 8$$$4 8$$$29%%%29%%% "y446666663;28SE?? BBBB3;28SE?? BBBB3;28SE?? BBBB3;28SE?? BBBB/7rxBG/L/L/LLLLL/7rxBG/L/L/LLLLL"e####"e####"e####"e####4 4 !"AAACA AAAA.6bhy.A.AAAAA/7rx/L/L/LLLLL/7rx{{::::bj)))i(((h'''bj)))T"""QQbj111Qd+++QiU;;;bje444Qbj111Qi000Qd+++E"""Qi000QiU;;;RZ YXRZ DAARZ(((AT"""AYE222RZU+++ARZ(((AY'''AT"""5AY'''AYE222T"""QE***2:...9---8,,,2:...$'''$u555!E222!2:666!4>>>!9%@@@2:5999!2:eDDD!9555!4000'''!9555!9%@@@ S St  Sq  Y YQ  ^ ^! $$$$!  """Q'''33T"""3Q991%%%>""">***$!  """Q''' c c  c  i ia  n n1 %%%sssyyq!!!~~A&&&##D!!!#A))!$$$.!!!.q)))CCd###Ca IIA&&&N###N+++##D!!!#A))!$$$.!!!.q)))##D!!!#A))!$$$.!!!.q)))4 1### a(((ss&&&s),,,sY777s###y!!!y---s)???y >>>yq)))~&&&~A...s&&&~5111~A...~A5 KKKcc%%%c"""C i Ca(((ia(((%%%n%%%I&&&000IA...a888 S# S#D !!! S#A  Y S) Y! $$$ S)! $$$ ^S!!! S.!!! Y """ ^^,,, Y  *** ^^! 444SSt$$$Sq!!! 3Y 3Q'''YQ'''$$$^$$$ 9%%%/// 91---Q777 S# S#D !!! S#A  Y S) Y! $$$ S)! $$$ ^S!!! S.!!! Y """ ^^,,, Y  *** ^^! 444 #s #s  #s  )S #y )Sq !!! #yq !!! .# #~ )Y ..))) )YQ ''' ..q 111 c3 c3T """ c3Q  i c9 i1 %%% c91 %%% nc""" c>""" i### nn--- i +++ nn1 555sCsCd###sCa y#sIy#A&&&sIA&&&~s###sN###y)$$$~~...y)!,,,~~A666SSt$$$Sq!!! 3Y 3Q'''YQ'''$$$^$$$ 9%%%/// 91---Q777cc%%%c"""C i Ca(((ia(((%%%n%%%I&&&000IA...a888#s#s&&&#s###)S!!!#y!!!)Sq)))#yq))).#&&&#~&&&)Y'''..111)YQ///..q999S#&&&S#D111S#A...Y,,,S),,,Y!444S)!444^S111S.111Y 222^^<<<Y :::^^!DDDsCsCd###sCa y#sIy#A&&&sIA&&&~s###sN###y)$$$~~...y)!,,,~~A6663S!!!3St,,,3Sq)))9c3'''3 3'''9c>:::3 3Q///>3 2223,,,9i--->>37779i;;;>>>JJJS#s###S#s...S#s+++YS)))S)S)))Y^!<<<S)Sq111^S)444S.#...Y 3///^^S999Y 91===^^^!LLLSSt$$$Sq!!!3Y3Q'''YQ'''$$$^$$$9%%%///91---Q777"c""""c---"c***(C((("i((((Ca000"ia000----"n---(I...-888(IA666-a@@@r2r"""r2r---r2r***xR(((r8R(((x];;;r8Ra000}b(333r="---x2...}mR888x8!<<<}m]KKK3;28SE3R3R3R RRRRC#SE2:"(A3bh2O2O2O OOOOS 8@!BH8U8U8UUUUU:B"(A3bh:W:W:WWWWW$AT"""$...ATD111!4$???!...-T:::$D111#4$???/tdKKK&dTBBB"(###ARX&&&"(T222ARX555!28dCCC!222-RX>>>$BH555#28dCCC/rx$OOO&bhFFF08!BH0M0M0MMMMM3 6>bhuBH6U6U6UUUUU8@#bh8W8W8WWWWWD!!!Ct$$$D4000Ctd3334$???t,,,>666N$///!===+4$GGG$D4@@@G$$$Cw'''Gd333Cw6667TBBBw///>999N'222!4@@@+7TJJJ$GdCCCBH%%%Crx(((BHt444Crx$77728dCCCrx000>:::N"(333!DAAA+28dKKK$BHtDDD191#RY1O1O1OOOOO3 7?rxry7Y7Y7YYYYY9A5'QSQZ9[9[9[[[[[d###E&&&dT222E555TDAAAt,,,>666N$///!===+4$GGG$D4@@@h'''E***h666ED999XEEEx000>:::N(333!DAAA+8dKKK$HtDDDbi(((E+++bi$777ET:::RYFFFry111>;;;N")444!TBBB+29tLLL$BIEEE191#RY1O1O1OOOOO3 7?rx TVT]7^7^7^^^^^9A:,VXV_9`9`9`````4(((Jd+++4$777JdT::: $FFFt,,,>666N$///!===+4$GGG$D4@@@8,,,Jh///8d;;;Jh>>> (TJJJx000>:::N(333!DAAA+8dKKK$HtDDD29---Jbi00029t<<<Jbi$??? ")dKKKry111>;;;N")444!TBBB+29tLLL$BIEEE191#RY1O1O1OOOOO3 7?rxAU@V^`^g7h7h7hhhhh9ACWBX`b`i9j9j9jjjjj%T222(555%TDAAA(tDDD 4D4PPPt,,,>666N$///!===+4$GGG$D4@@@%X666(999%XEEE(4HHH 4HtTTTx000>:::N(333!DAAA+8dKKK$HtDDD%RY777( :::%RYFFF( DIII 4BIPTUUUry111>;;;N")444!TBBB+29tLLL$BIEEE/7rxbg/N/N/NNNNN 6 !!!!5=RXse275S5S5SSSSS7?rxRW7U7U7UUUUUD!!!s$'''D4000s$6664$???t,,,>666~T222!===+4$GGG'tdCCCF###s&)))FT222s&48886DAAAv...>888~V444!$???+6DIII'vEEEBG$$$s"'***BGd333s"'D99927TBBBrw///>999~RW555!4@@@+27TJJJ'rwFFF08&0R0R0RRRRR"8 ####6>bhwbh6W6W6WWWWW8@%PRPX8Y8Y8YYYYYd###d+++dT222dT:::TDAAAt,,,>666t444!===+4$GGG)EEEg&&&g...g555g===WtDDDw///>999w777!4@@@+7TJJJ)4HHHbh'''bh///bh666bh>>>RXEEErx000>:::rx888!DAAA+28dKKK)DIII08+bh0W0W0WWWWW'= ((((6>bh |SUS[6\6\6\\\\\8@*UWU]8^8^8^^^^^4(((j5554$777jtDDD $FFFt,,,>666nD999!===+4$GGG.dTJJJ7+++j8887T:::j$GGG 'DIIIw///>999nG<<<!4@@@+7TJJJ.gMMM28,,,j99928d;;;j4HHH "(TJJJrx000>:::nBH===!DAAA+28dKKK.bhNNN08:N9OWYW_0`0`0`````01 11116>bh@S?T\^\d6e6e6eeeee8@BUAV^`^f8g8g8ggggg$D111%':$GGG$D4@@@%':$QUVVV 34$OOOt,,,>666%~TBBB!===+4$GGG%'7tdSSS$G444%':'JJJ$GdCCC%':'TXYYY 37TRRRw///>999%~WEEE!4@@@+7TJJJ%'7wQUVVV$BH555%':"(KKK$BHtDDD%':"(UYZZZ 328dSSSrx000>:::%~RXFFF!DAAA+28dKKK%'7rxRVWWW aqq!q!T"""q!w{###q!w{E222:::;;;:::A>>>:::A%1MMM:::AtLLL:::AuPXPRPXYuYuYuPvPvwww3*("(C:&&'''("(C:&&Q///B A &&&B#s,,---B A A...bTB4L7)a-f===HBHrdRD\**HBHc3Z,@,@vNNN##IIIq111##HBHYYY$7$7;;;##HBHYYY$7$7#CCC##HBHYYY$7$7#HHH##IIIq#AAA##HBHYYY$7$7;#OOOSESE7+++SE828cUG#4#4555HBHcUOOseW555SE828cUG#4#4555BLLL!!!HBH\\\**+++Dq!!!A4 %%%%%%A4(((  "  1$$&& ]###$&9#8#8#:#: ::::  t$$$ q!!!  d a  t$$$ q!!!  D))) A&&& s s s y yq!!! ~ ~A&&& # #D!!! #A ) )!$$$ .!!! .q))) S St$$$ Sq!!! Y YQ''' ^$$$ ^!,,, # #D!!! #A ) )!$$$ .!!! .q)))  $ !    """  Q'''  4 1  ###  a((( C Cd### Ca I IA&&& N### N+++ c c%%% c""" i ia((( n%%% n1--- C Cd### Ca I IA&&& N### N+++ C Cd### Ca I IA&&& N### N+++ 3 3T""" 3Q 9 91%%% >""" >***  4((( 1%%% ### +++ ((( a000 a000 3 3$''' 3!$$$ 9c""" 3 """ 9c*** 3 *** >3''' 3''' 9i((( >>222 9ia000 >>::: sC sCd### sCa y# sI y#A&&& sIA&&& ~s### sN### y)$$$ ~~... y)!,,, ~~A666 #s #s&&& #s### )S!!! #y!!! )Sq))) #yq))) .#&&& #~&&& )Y''' ..111 )YQ/// ..q999 sC sCd### sCa y# sI y#A&&& sIA&&& ~s### sN### y)$$$ ~~... y)!,,, ~~A666 C C4 C1  Is C Is ### C ### NC C Iy!!! NN+++ Iyq ))) NN 333 S St$$$ Sq!!!  3 Y  3Q''' YQ''' $$$ ^$$$  9%%% ///  91--- Q777 c c%%% c""" C i Ca((( ia((( %%% n%%% I&&& 000 IA... a888 #s #s&&& #s### )S!!! #y!!! )Sq))) #yq))) .#&&& #~&&& )Y''' ..111 )YQ/// ..q999 3 3$''' 3!$$$ 9c""" 3 """ 9c*** 3 *** >3''' 3''' 9i((( >>222 9ia000 >>::: C C4((( C1%%% Is### C### Is+++ C+++ NC((( C((( Iy))) NN333 Iyq111 NN;;; sC((( sCd333 sCa000 y#... sI... y#A666 sIA666 ~s333 sN333 y)444 ~~>>> y)!<<< ~~AFFF c c%%% c""" C i Ca((( ia((( %%% n%%% I&&& 000 IA... a888 S#s### S#s... S#s+++ YS))) S)S))) Y^!<<< S)Sq111 ^S)444 S.#... Y 3/// ^^S999 Y 91=== ^^^!LLL sC%%% sC4000 sC1--- y#s+++ sIs+++ y#~A>>> sIs333 ~sI666 sNC000 y)S111 ~~s;;; y)YQ??? ~~~ANNN 2s 2s&&& 2s### 8S!!! 2y!!! 8Sq))) 2yq))) =#&&& 2~&&& 8Y''' =.111 8YQ/// =.q999 B$$$ B$/// B!,,, Hc*** B *** Hc222 B 222 M3/// B/// Hi000 M>::: Hia888 M>BBB R$$$ R$/// R!,,, 2r*** Xr*** 2}1=== Xr222 H555 ]B/// 8R000  r::: 8XA>>>  }1MMM !S # 3% !cU !4 !Qd### "$/// *.d;;; !%T222 !28$$$ !Qbh''' ""(333 *.bh??? !%RX666 #T""" !S%%% .--- (N$777 !^4000 #W%%% !S((( .000 (N'::: !^7333 #RX&&& !S))) .111 (N"(;;; !^28444 %t$$$ !U$''' .--- (N$777 !^4000 %x((( !U(+++ .111 (N(;;; !^8444 %ry))) !U"),,, . 222 (N")<<< !^29555 *D))) !Zt,,, .--- (N$777 !^4000 *H--- !Zx000 .111 (N(;;; !^8444 *BI... !Zry111 . 222 (N")<<< !^29555 &d333 !)666 .--- (N$777 !^4000 &h777 !)::: .111 (N(;;; !^8444 &bi888 !);;; . 222 (N")<<< !^29555 #T""" $4((( .--- (N$777 $d333 #V$$$ $6*** ./// (N&999 $f555 #RW%%% $27+++ .000 (N"'::: $bg666 %t$$$ &%t,,, .--- (N$777 &.555 %w''' &%w/// .000 (N'::: &.888 %rx((( &%rx000 .111 (N"(;;; &.999 *D))) +z666 .--- (N$777 +~T::: *G,,, +z999 .000 (N'::: +~W=== *BH--- +z::: .111 (N"(;;; +~RX>>> %T222 &(;4HHH .--- (N$777 &dCCC %W555 &(;7KKK .000 (N'::: &gFFF %RX666 &(;28LLL .111 (N"(;;; &bhGGG&55555   A At$$$ A%1%%% A%1e444 <<<=== <<r5sRYr]] % R_B     BCGGGBO     BqA....Bqs++++BM"BL?sBCC!CPKIZZ'3030-data/pass/__pycache__/scalars.cpython-311.pycnu[ bg ddlZddlZddlZddlZejZejZ ej Z ej Z ejZejZejZGddZGddZGddZGdd Zejd ejeejeejd ejeejdejd ejd ejd ejdejd ej dejeejejdej dejeejdej dej dejdejdejeejeejeejdejddejddejdejddejddejj ejj!ejj"ej j#ejj$dzej%j&dzejj'ejj(ej)ej)ddej)ddej)ddej)dej)dej)ddej)ej)ej)ejdd d!ej)ej*dd d!ej)dej)ddej+ej+dej+ddej+ddej+ddej+d"ej+d#ej+ej+dej+ej,dej+dej+ddej-dej-ej dej-d$ej-ejd$ej-d%ej-ejd&ej-e.d'd(gej-e.d'd(g)ej Z ejZ ej Z ejZejZ/ej+Z0ejdZejdZej1dej )Z2e3e e3e e3e e3e/e3e0e3ee3ee3e2ej4ej55e3edddn #1swxYwYe6e e6e e6e e6e/e6e0e6ee6ee6e2ej4ej55e6edddn #1swxYwYe7e e7e e7e e7ee7e/e7e0e7ee7e2ej8ej ej!ej j ej j!ej&ej9ej$ej(ej'e:e;e<ej=ej>ej?ej@ejAejBejCejDejEejFejGejHejIejJejKejLejMejNejOejPejQejRejSejTejUejVejWeXe Xe Xe XeXeXeXeYe Ye Ye YeYeYeYeZe Ze Ze ZeZeZeZe[e [e [e [e[e[e[e\de \de \de \de\de\de\ddS)*NceZdZdefdZdS)DreturncdS)Nrselfs w/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/scalars.py __index__z D.__index__qN)__name__ __module__ __qualname__intr rr r rrs/3r rceZdZdefdZdS)CrcdS)N@rrs r __complex__z C.__complex__srr N)rrrcomplexrrr r rrs/Wr rceZdZdefdZdS)BrcdS)Nrrs r __int__z B.__int__r r N)rrrrrrr r rrs/r rceZdZdefdZdS)ArcdS)Ng@rrs r __float__z A.__float__!ssr N)rrrfloatr rr r rr s/5r rrz1.2s2jrg333333 @12g@s2.5shellohellozutf-8)encodingD)ms2019s2019ir,35Tstesttest)aO)br3)dtype)]sysdatetimedtpytestnumpynpbool_r4uint64u8int64i8float64f8 complex128c16str_Ubytes_Srrrr complex64int8int16int32uint8uint32float16float32realimagdataflagsitemsizeuint16ndimstridesshape datetime64date timedelta64 timedeltavoidobjectb_tdarrayARrwarnsComplexWarningr!rr5sizesqueezebyteswap transposestring_byteshortintcintpint_longlongubyteushortuintcuintpuint ulonglonghalfsingledoublefloat_ longdouble longfloatcsingle singlecomplexcdoublecomplex_cfloat clongdouble clongfloat longcomplexitemtolistravelflattenreshaperr r rs    RXZZRY[[ RXZZRZ\\bmoo BGII BIKK      R  QQSS  QQSS  b  aacc  d  U  e         1133  2  3  4  3  6  !!##  1133  QQSS  (  '7  'G$$$$'7####     a  1       a  a  a  f  g  fc  mbmoo  kbk$1%%&&&  gbgdAq!!"""  d  dCqq#q)q$st~r~a  !!!|r|AttS     &:z*+++Z01111RXZZRY[[RZ\\bmoo RXZZR^ BGCLL BIcNN RXarz"""BBBBBAABV\"#$$  CHHH               b b b b b aab V\"#$$ E#JJJ                                                                        !  1  1  1  A !  ! s$ \  \$'\$ ^00^47^4PKIZU2JJ2data/pass/__pycache__/arrayterator.cpython-311.pycnu[ bgxUddlmZddlmZddlZejdZded<ej eZ e j e j e je je je je je e D]Ze de de dde de ddddfdS) ) annotations)AnyN z"np.ndarray[Any, np.dtype[np.int_]]AR_i8.)rrr) __future__rtypingrnumpynparanger__annotations__lib Arrayteratorar_itervarbuf_sizestartstopstepshapeflat __array__i|/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/arrayterator.pyrs""""""",5BIbMM9999 &  e $ $         A   Q rPKIZ H H 1data/pass/__pycache__/bitwise_ops.cpython-311.pycnu[ bgddlZejdZejdZejdZejdZ ej dZ e dZ edZejgdejZedeezeez eezeez eezeezeez eezeez eezeezeez eezeez eezeezeez eezeez eezeezeez eezeez eezee zee z ee zee z ee zee zee z ee zee z ee zeezeez eezeez eezeezeez eezeez eeze e ze e z e e ze e z e e ze eze ez e eze ez e eze eze ez e eze ez e ezee zee z ee zee z ee zee zee z ee zee z ee ze e ze e z e e ze e z e e ze eze ez e eze ez e eze e ze e z e e ze e z e e ze eze ez e eze ez e ezeeee e edS)N)rr)dtypeF)write)numpynpint64i8uint64u8int32i4uint32u4bool_b_boolbintiarrayARsetflags{/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/bitwise_ops.pyrs RXa[[RYq\\ RXa[[RYq\\ RXa[[DGGCFF RXiiirx((( % bbRRRbbRRRbbRRRbbRRRaaQQQbbRRRaaQQQbbRRRbbRRRbbRRRbbRRRaaQQQbbRRRaaQQQbbRRRbbRRRaaQQQaaQQQrPKIZCepp,data/pass/__pycache__/simple.cpython-311.pycnu[ bgt dZddlZddlZddlmZejddgZdZeejddgedkeje keje ejej ejdejdejeje ejdejej d fgd Z eje d gZ eje d d ejdfgZejedgZejedd ejdfgZejedefgZejeejej ejdffeje e keje ej keje dkeje dkeje eje keje ejdkdZeedeDeeeeeededdeddedd<ejdZeddddfeddeddddf<eeeeejdZeee eeeejee eedkedkedkedkedkedkdekdekdekdekdekdekedzdezedz Zedz dez edzZedzdezedzZejddgZ!edz de!z ejddgZ"e"dzZ"edzde!zedzZedzde!zedzZe#ede#de!edzdezedzZedzdezedzZedz dez edzZedzdezedzZedz dez edzZedzdezedzZe e e$eeejddg%dS)z-Simple expression that should pass with mypy.N)Iterablec|SNxs v/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/simple.py ndarray_funcr  Hfloat64)U rr)Ru1)Gr)Br)rrrrr)rrrfield1c|Srrr s r iterable_funcr;r rcg|]}|Srr).0elements r rAsWr.)r ).rg?g@)&__doc__operatornumpynpcollections.abcrarrayr dtypefloatrint32two_tuples_dtypethree_tuples_dtypestr_mixed_tuples_dtypeshape_tuple_dtypeshape_like_dtypeobject object_dtypeint8riterziponesarray_2dlenstr array_scalarintbytesindexbool nonzero_array float_arraydivmodabs transposerrr rCs733$$$$$$ !Q    XRXq!f    u %"(F ;:: $% !C!#45 () '#rw):; 6"# "(RWaL !""" 52:$9("(5//!!828I&&&&    eU E5aaaac aaa 276??!RaR!RaRE E rx{{ Lll|\      E U U U E U  E   E   E  !Q   MbhSz"" q  ]!  M uaq- U !  U !  U !  E   E   E  E  !QrPKIZ1data/pass/__pycache__/comparisons.cpython-311.pycnu[ bg UddlmZddlmZddlZejZejZ ej Z ej Z ejZejZejZejZejddZejddZejZeZeZe Z!e"Z#dZ$ej%dgZ&de'd<ej%d gej Z(d e'd <ej%d gZ)d e'd<ej%dgZ*de'd<ej%dgZ+de'd<ej%ejdgZ,de'd<ej%ejdgZ-de'd<ej%d ge. Z/de'd<e&e&ke&e(ke&e)ke&e*ke&e+ke(e&ke(e(ke(e)ke(e*ke(e+ke)e&ke)e(ke)e)ke)e*ke)e+ke*e&ke*e(ke*e)ke*e*ke*e+ke+e&ke+e(ke+e)ke+e*ke+e+ke,e&ke,e(ke,e)ke&e,ke(e,ke)e,ke-e-ke/e/kd e/ke/d keekeekee#keekee kee)kee$keekeekee#kee keekee keekee!kee keekeekeekeekee)kee$keekee kee keekeekeekeekeekeekee!kee#kee)kee$keeke eke ekeekeekeekeekeekeeke!eke#eke)eke$ekeekee kee keekeekeekeekeekeekee!kee#kee)kee$keeke eke ekeekeekeekeekeekeeke!eke#eke)eke$eke e ke e ke eke eke eke eke eke e!ke e#ke e)ke e$ke e ke e kee kee kee kee kee ke!e ke#e ke)e ke$e kee kee keekeekeekeekeekee!kee#kee)kee$ke eke ekeekeekeekeekeeke!eke#eke)eke$eke e ke e ke eke eke eke eke eke e!ke e#ke e)ke e$ke e ke eke eke eke eke eke e!ke e#ke e)ke e$ke e ke e kee kee kee kee kee ke!e ke#e ke)e ke$e ke e kee kee kee kee kee ke!e ke#e ke)e ke$e kee keekee#keekeekee)kee$kee keekee keekee#keekeekee)kee$ke ekeeke#ekeekeeke)eke$eke ekeeke ekeekeekeeke#eke)eke$ekdS)) annotations)AnyND)rTz#np.ndarray[Any, np.dtype[np.bool_]]AR_br)dtypez$np.ndarray[Any, np.dtype[np.uint32]]AR_uz"np.ndarray[Any, np.dtype[np.int_]]AR_ig?z$np.ndarray[Any, np.dtype[np.float_]]AR_fy?z&np.ndarray[Any, np.dtype[np.complex_]]AR_c1z)np.ndarray[Any, np.dtype[np.timedelta64]]AR_mz(np.ndarray[Any, np.dtype[np.datetime64]]AR_Mz%np.ndarray[Any, np.dtype[np.object_]]AR_O)0 __future__rtypingrnumpynp complex128c16float64f8int64i8uint64u8 complex64c8float32f4int32i4uint32u4 datetime64dt timedelta64tdbool_b_boolbcomplexcfloatfintiSEQarrayr __annotations__r r rrrrobjectr{/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/comparisons.pyr=s) """""""bmooRZ\\ RXZZRY[[R\^^RZ\\ RXZZRY[[R]1cR^As RXZZDFF GII EGGCEE,4BHdV,<,<<<<<-5RXqc-K-K-KKKKK+328QC==8888-5RXse__<<<r0s BHRW   D"*-bj/ABCCrx #q#tC:3, 7 7888C5cUvh ? ?@@@C5cUvvxxj A ABBB627B (BJ!=?O PQQQs<*q6     ")U         A A I I tqd|vr!PKIZ8 8 0data/pass/__pycache__/einsumfunc.cpython-311.pycnu[ bgZUddlmZddlmZddlZgdZejdejdejdgZgdZ gd Z gd Z gd Z ej dej Zd ed<ej dej Zded<ejdeeejdeeejde e ejde e ejde e ejdee ejdeee e ejde e d ejde e edejde e eejde e edeejdeeejdeeejde e ejde e ejde e ejdee ejdeee e dS)) annotations)AnyN)TTT)rrr)g?g@g@)y?y@y@)123)dtypez%np.ndarray[Any, np.dtype[np.float64]]OUT_fz(np.ndarray[Any, np.dtype[np.complex128]]OUT_czi,i->iz i,i,i,i->ic16unsafe)r casting)out)r rr) __future__rtypingrnumpynp AR_LIKE_buint32 AR_LIKE_u AR_LIKE_i AR_LIKE_f AR_LIKE_c AR_LIKE_Uemptyfloat64r __annotations__ complex128r einsumboolint einsum_pathz/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/einsumfunc.pyr(s"""""""    RYq\\929Q<<1 6 II OO LL OO /7rx/L/L/LLLLL2:"(1BM2R2R2RRRRR  (Iy)))  (Iy)))  (Iy)))  (Iy)))  (Iy)))  (Iy)))  , 9iCCC  (Iy6666  (IyhGGGG  (Iye4444  (IyX5QQQQxI...xI...xI...xI...xI...xI...|Y 9iHHHHHr&PKIZp}aa0data/pass/__pycache__/simple_py3.cpython-311.pycnu[ bg`<ddlZejddgZeezdS)N)numpynparrayz/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/simple_py3.pyr s5!Q r PKIZX.data/pass/__pycache__/flatiter.cpython-311.pycnu[ bgvddlZejdjZejeejeje ee eedegdededde e ej ej dS)N)r)rr.)numpynpemptyflatabasecopycoordsindexiternext __array__dtypefloat64x/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/flatiter.pyrs BHVQQ!))) #!!!  HBHRZ !!!!!rPKIZ6//1data/pass/__pycache__/fromnumeric.cpython-311.pycnu[ bgdZddlZejddeZejddejZededej dZ ejdZ dZ ejdej Z eje deje deje dejedejedejedgejedgeje d eje d eje d ejed ejed eje ddgejeddgeje d eje d eje d ejed ejed ejeddejeddeje eje eje ejeejeeje dd eje dd eje dd ejedejedeje deje deje dejedejedejedejedejedejedejeejeejed ejed ejeejeejed ejed ejeddejeddejeddgejeddgeje d eje d eje d ejed ejed eje eje eje ejeejeejeejeejeejeeje eje eje ejeejeej eej eej!e ej!e ej!e ej!eej!eej"dge ej"dge ej"dge ej"dgeej"dgeej#e ddej#e d d ej#e ddej#e dd ej#e dd ej#edd ej#edd ej#edd gd dgej$e ej$e ej$e ej$eej$eej$ed ej$ed ej%e ej%e ej%e ej%eej%eej%ed ej%ed ej%edej%edej&e ej&e ej&e ej&eej&eej&ed ej&ed ej&edej&edej'e ej'e ej'e ej'eej'eej(e ej(e ej(eej(ed ej(edej)e ej)e ej)e ej)eej)eej)ed ej)ed ej)edej)edej*e ej*e ej*e ej*eej*eej*ed ej*ed ej*edej*edej+e ej+e ej+e ej+eej+eej+e d ej+ed ej+ed ej+ed ej+edej+edej+e e ej+ee ej,e ej,e ej,e ej,eej,eej-e ej-e ej-e ej-eej-eej.e ej.e ej.e ej.eej.eej/e ej/e ej/e ej/eej/eej0e ej0e ej0e ej0eej0eej0ed ej0ed ej0edej0edej0e e ej0ee ej1e ej1e ej1e ej1eej1eej1ed ej1ed ej1edej1edej1e e ej1ee ej2e ej2e ej2e ej2eej2eej2ed ej2ed ej2edej2edej2e e ej2ee dS)z(Tests for :mod:`numpy.core.fromnumeric`.NT)ndmindtypeg?F)write)r)axis)r )keepdims)out)3__doc__numpynparrayboolAfloat32Bsetflagsbool_abcdtakereshapechooserepeatswapaxes transpose partition argpartitionsortargsortargmaxargmin searchsortedresizesqueezediagonaltraceravelnonzeroshapecompressclipsumallanycumsumptpamaxaminprodcumprodndimsizearoundmeanstdvar{/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/fromnumeric.pyrCs.. BHT$''' BHS,,,     BHTNNBJsOO BHS ###1 1 1 1 1 A3A3  1a  1a  1a  1a  1a  !dD\  !c3Z  !Q  !Q  !Q  !Q  !Q  Aq!  Aq!  Q  Q  Q  Q  Q  Q  Q  Q  Q  Q111111 1  1a  1a  !  !  !!  !!  !  !  !!  !!!a!a!qc!qc  !V  !V  !V  !V  !V  1  1  1  1  1  A  A        1  1       TFA  TFA  TFA  TFA  TFA1c2q1d41a1a1aAq6Aq6q q q q q qqqqq q q q q qqqqq4q4q q q q q qqqqq4q4  !  !  !  !  ! q q q qqq4     DD     DD     DDqq  1  1  1  1  1            !  !  !  !  !      DDqqq q q q q qqqqq4q4qaqaq q q q q qqqqq4q4qaqarAPKIZTgg2data/pass/__pycache__/ufunc_config.cpython-311.pycnu[ bg` dZddlZdededdfdZddedededdfd Zdededefd ZGd d Z Gd dZ GddZ ej Z ejZejZ ejdejdejdejdejdej ejdejejeejeejeeje eje eje ejejed5 dddn #1swxYwYeje dd5 dddn #1swxYwYejdie ejeejedS#ejdie ejeejewxYw) z,Typing tests for `numpy.core._ufunc_config`.NabreturncdSNrrs |/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/ufunc_config.pyfunc1r .ccdSrr)rrrs r func2rr r cdSrrr s r func3rr r ceZdZdeddfdZdS)Write1rrNcdSrrselfrs r writez Write1.write r r )__name__ __module__ __qualname__strrrr r rr s&(s(t((((((r rc$eZdZddededdfdZdS)Write2.rrrNcdSrr)rrrs r rz Write2.write r r .rrrrintrrr r rr s.66s6s6T666666r rceZdZdedefdZdS)Write3rrcdSrrrs r rz Write3.writer r Nr!rr r r$r$s&'s's''''''r r$)allignore)dividewarn)overcall)underraise)invalidi)r+r&log)r+r(r*r r)__doc__numpynprr"r floatrrrrr$geterr _err_default getbufsize_bufsize_default geterrcall_errcall_defaultseterr setbufsize seterrcallerrstaterr r r>s22&S&S&T&&&&66S6S6U6T6666%S%S%S%%%%))))))))77777777((((((((ry{{  2=?? 2=??$ BI$ BIX BI6 BIF BIg BIKKKBM$BMOOOBM%BM%BM%BM&&((BM&&((BM&&((BMOOO %V , , ,                  &&((5u = = =                  BI BM"###BM"#####BI BM"###BM"####sU=DHF' H'F++H.F+/H G HGH"G#H/IPKIZWf772data/pass/__pycache__/index_tricks.cpython-311.pycnu[ bgUddlmZddlmZddlZddgddggZddgddggZd d gd d ggZd dgddggZ ej eej Z de d<eje ejeeje eje jejejeje jeeje eejeeeje eeje eejeeeje eejdddeejdddejgddejgdddejddejedejeddejeddejeddejd dejdddejddddd!fejdddejddddd!fejddejddddfejdddd"gd#fejddejddddfejdddd"gd#fejedejededeje deje d$ejdejddeje dS)%) annotations)AnyNTg?g@g@g@1234)dtypez#np.ndarray[Any, np.dtype[np.int64]]AR_i8))%))r F)orderiU)rr )rrclip)mode)rr)rwrap)rrrr .)rrr) __future__rtypingrnumpynp AR_LIKE_b AR_LIKE_i AR_LIKE_f AR_LIKE_Uarrayint64r__annotations__ ndenumerateiternextndindex unravel_indexravel_multi_indexmgridogrid index_exps_ix_ fill_diagonal diag_indicesdiag_indices_from|/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/index_tricks.pyr;sH"""""""D\D$< ( VaV  3Z#s $ 3Z#s $ -5RXirx-P-P-PPPPPuyyuyy^R^E^R^I^R^I^R^E^R^I^R^IZRZ1aZRZ1av&&&vS1111|$$$Y'''Yc2222YV4444Y-=>>>>\<0001Q1QR1Q1QR QqS QqS$q&[ Q!S))) #$$ac ac46ka1c999y|y|Yq\"""uQx1Ur9PKIZ-y /data/pass/__pycache__/ufunclike.cpython-311.pycnu[ bg,UddlmZddlmZddlZGddZgdZejdejdejd gZ gd Z gd Z eeegZ ej d d Zded<ejeeje eje eje eje eje eejeeje eje eje eje eejeeje eje eje eje edS)) annotations)AnyNc.eZdZd dZd dZd dZd d Zd S)Objectreturnc|SNselfs y/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/ufunclike.py__ceil__zObject.__ceil__ c|Sr r r s r __floor__zObject.__floor__ rrvalueobjectboolcdS)NTr )r rs r __ge__z Object.__ge__ str%np.ndarray[Any, np.dtype[np.object_]]cFtjdt}||d<|S)Nr dtype)npemptyr)r rets r __array__zObject.__array__s$hr(((B rN)rr)rrrr)rr)__name__ __module__ __qualname__rrrrr rr rrsdrr)TTF)r#r$r%)g?g@g@U5rz"np.ndarray[Any, np.dtype[np.str_]]AR_U)out) __future__rtypingrnumpyrr AR_LIKE_buint32 AR_LIKE_u AR_LIKE_i AR_LIKE_f AR_LIKE_Ozerosr'__annotations__fixisposinfisneginfr rr r7s"""""""           RYq\\929Q<<1 6 II OO VXXvvxx * +328AT+B+B+BBBBByyyyyyd  I  I  I  I  I4  I  I  I  I  I4 rPKIZj/data/pass/__pycache__/lib_utils.cpython-311.pycnu[ bgddlmZddlmZddlZeZejdejZ dd Z ej e ej ej d ej dej e ej ejejd e ejeje ejde dS)) annotations)StringION )dtypeaintreturnboolcdS)N)rs y/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/lib_utils.pyfuncr stest)outputzbinary representation)rrr r ) __future__riornumpynpFILEarangefloat64ARr deprecatedeprecate_with_doc byte_boundsinfosourceinterplookforr rr r"s#""""""xzzRYr$$$  T  fdrzrz||$  ")D!!!!  "4000000rPKIZ]iµ1data/pass/__pycache__/lib_version.cpython-311.pycnu[ bg+ddlmZedZejejejejejejejeekeekedkeekeekedkdS)) NumpyVersionz1.8.0N) numpy.librversionvstringmajorminorbugfix pre_release is_devversion{/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/lib_version.pyrs"""""" ,w    77'7'7r PKIZl, ,data/pass/__pycache__/ufuncs.cpython-311.pycnu[ bgddlZejdejgdejdejdejejdejdgdejdd ejdd dd g ejjdejjejjej ej dgdS) N)r)out)rrr)rrrr)axeszD->D) signaturecdS)Nr v/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/ufuncs.pyrsr )extobj) numpynpsinemptymatmulonestypes__name____doc__absarrayr r rrs q yyyqhbhqkk  '"')  gbgi007O7O7OPPPPqFq"a&''''  Qxrx}}r PKIZȦ -data/pass/__pycache__/literal.cpython-311.pycnu[ bg3>UddlmZddlmZddlmZddlZddlZej dZ e de hdZ e hdZe hd Ze eejd fe e jfe ee jefe e jfeee jd fe e jfe e jfe eej d feeejd feeejd feeejd feeejd d fe eeje fe eeje fe eeje fe eeje d fe eej d d feeeje d fe eeje fe eej!d fe eej"d fgZ#d e$d <e#D]T\Z%Z&e%D]Z'e&e' e e%z Z(e(D]6Z'ej)e*5e&e' dddn #1swxYwY7UdS)) annotations)partial)CallableNF)write>NACFK>Nrrr >Nrr z list[tuple[frozenset, Callable]] order_list)order)+ __future__r functoolsrcollections.abcrpytestnumpynparrayARsetflags frozensetKACFACFCFndarraytobytesastypeintcopyreshapeflattenravelzerosonesemptyfull zeros_like ones_like empty_like full_likeaddasarray asanyarrayr __annotations__ order_setfuncr invalid_ordersraises ValueErrorw/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/literal.pyr7sW"""""""$$$$$$  RXa[[ % y+++,,i%%%&&Y   772:q ! !" 2: 7729c " "# 27O''"*a ! 2: 28 7728Q   1  !  1  !Q    772=" % %& 772< $ $% 772=" % %& 772<Q ' '( 77261a !''"*b! $ $% 7728R ! 772:q ! !" 772=! $ $%+0 0"OIt 5I%N V]: & &   Du                    s7 HH H PKIZ$)data/pass/__pycache__/mod.cpython-311.pycnu[ bg* ddlZejdZejdZejdZejdZ ej dZ ej dZ ejddZejdZedZedZedZejdgejZedejdgejZedeezeezeezeeeeeeeeeeezeezeezeezeezeezeezeezeeeeeeeeeeeeeeeeeeeeeeeeeezeezeezeezeezeezeezeezeeeeeeeeeeeeeeeeeeeeeeeeeezeezeezeezeeze eze eze e ze e zeezeeeeeeeeeeeeeeeeee eee ee e ee e eeeeezeezeezeezeezee zee ze e ze e zeezeeeeeeeeeeeeeeeee eee eee e ee e eeeeezeezeezee ze e zeezeeeeeeeeeeeeeee ee e eeeeezeezeezeezeeze e zeezeeeeeeeeeeeeee eee e eeedS)ND)dtypeF)write)numpynpfloat64f8int64i8uint64u8float32f4int32i4uint32u4 timedelta64tdbool_b_boolbfloatfintiarrayARsetflagsAR2divmods/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/mod.pyr's RZ]] RXa[[RYq\\RZ]] RXa[[RYq\\R^As RXa[[DGG E!HHCFF RXqc""" % bhs".))) 5 RSbr2r3sBQQQRRRRRr1 r1 r1 r2r2r2r2r2BBBRRRRRq" q" q" r2r2r2r2r2QQQRRRRRRRr1 r1 r1 r2r2r2r2r2r2r2BBBRRRRRRRq" q" q" r2r2r2r2r2r2r2QQQRRRr1 r1 r1 r2r2r2r2BBBRRRRq" q" q" r2r2r2r2r%PKIZS ''-data/pass/__pycache__/modules.cpython-311.pycnu[ bgSddlZddlmZejejejejejejej ej ej ej ej ejejejjejjejjejjej jej jej jej jej jej jej j ejejejejejjejjejjejjej jej jej jejjejdS)N)f2py)numpynprchar ctypeslibemathfftliblinalgma matrixlib polynomialrandomrectestingversionformatmixinsscimath stride_tricksextras chebyshevhermite hermite_elaguerrelegendre__path__ __version____git_version____all__w/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/modules.pyr$sh                       r"PKIZcAĿ559data/pass/__pycache__/warnings_and_errors.cpython-311.pycnu[ bgddlZejdejddejdddejddddS)Ntest)ndimerror)r msg_prefix)numpynp AxisError/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/warnings_and_errors.pyrsr  V  QQ  QQ7++++  QQ4((((((r PKIZn}< < 0data/pass/__pycache__/multiarray.cpython-311.pycnu[ bg3xUddlZddlmZejdgZejeje d<ejdgej Z ejdgej Z dgZdgZejeZeje eeZeeeejejejejejejejeeeejejejejejejejejee ejgdejgdddejgdejej d e!ejed ejeej"d ej#dgej#eej$e!e ej$ee ej$eej"ej%ee ej%e dej%d dej%e deej&ee ej&e dej&d dej'e ej(edgej)edgdej*e ej*e ej+e ej,ddej,eedej-ddej-eeddS)Ng?AR_f8)dtypeg?)TTF)rri8f8unsafe)castingy?)outg?Tr)max_work).numpynp numpy.typingtypingnptarrayrNDArrayfloat64__annotations__int32AR_i4uint8AR_u1 AR_LIKE_f AR_LIKE_i broadcastb_f8 b_i4_f8_f8nextresetindexitersndndimnumitershapesizeinnerwherelexsortcan_castrint complex128min_scalar_type result_typedotvdotbincountcopytoputmaskpackbits unpackbits shares_memorymay_share_memoryz/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/multiarray.pyr<s!)3%s{2:000!BH%%%!BH%%% E C r|E R\% . . T        Z             a###  999  HBHTNNC  E4  E2=(3333A35sEueubm$$$y%uatQuaU 5qa  E  %#  54&#  E  E  eA****AqE51------r:PKIZo -data/pass/__pycache__/numeric.cpython-311.pycnu[ bg UdZddlmZddlZGddejZejdZej d dddZ e Z d ed <ejd eZejeeje eje eje d eje dejeeje ejeeje ejeeje eje dde deje e deje dde deje e dejee eje e eje e eje e eeje e eje e eje e deje e dejeeje eje eje deje deje deje ddeje ddeje ddeje e eje e ej gdej gddej gdd ej!dej"dej#ee ej#e e ej#e e ej$ee ej$e e ej$e e ej%ee ej%e e ej%e e ej&ee ej&e e ej&e e dS)zh Tests for :mod:`numpy.core.numeric`. Does not include tests which fall under ``array_constructors``. ) annotationsNceZdZdS)SubClassN)__name__ __module__ __qualname__w/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib64/python3.11/site-packages/numpy/typing/tests/data/pass/numeric.pyrr sCr rzlist[list[list[int]]]B)r r T)keepdims)axisvalid)modesame)out)axes)rr )r )rr rF)sparse)'__doc__ __future__rnumpynpndarrayrint64i8arangereshapeAtolistr__annotations__emptyviewC count_nonzero isfortranargwhere flatnonzero correlateravelconvolveouter tensordotisscalarrollrollaxismoveaxiscrossindices binary_repr base_reprallcloseisclose array_equal array_equivr r r r=s #"""""rzRXa[[ BIbMM!Q""88::%%%% BHXH%%T""""  R  Q  B  Arq  QqT!Waggiig....  QWWYY ////  AaDGQWWYYW----  AGGIIqwwyyv....QAAA1  Q  Q  Q  Q  B  A  A1 61  Aq!  Aq!  AvvAA  999  999U####  999T""""q  Q  B  Aq  Aq  2q  1a  1ar1q!q!r1q!q!r PKIZrsbhAA   A Aq F F#  AS   1  1a 6 6D !!! 1t bhAA    a f Q  C  # bhAx Abh!Qz FrPKIZgdata/pass/arithmetic.pynu[from __future__ import annotations from typing import Any import numpy as np import pytest c16 = np.complex128(1) f8 = np.float64(1) i8 = np.int64(1) u8 = np.uint64(1) c8 = np.complex64(1) f4 = np.float32(1) i4 = np.int32(1) u4 = np.uint32(1) dt = np.datetime64(1, "D") td = np.timedelta64(1, "D") b_ = np.bool_(1) b = bool(1) c = complex(1) f = float(1) i = int(1) class Object: def __array__(self) -> np.ndarray[Any, np.dtype[np.object_]]: ret = np.empty((), dtype=object) ret[()] = self return ret def __sub__(self, value: Any) -> Object: return self def __rsub__(self, value: Any) -> Object: return self def __floordiv__(self, value: Any) -> Object: return self def __rfloordiv__(self, value: Any) -> Object: return self def __mul__(self, value: Any) -> Object: return self def __rmul__(self, value: Any) -> Object: return self def __pow__(self, value: Any) -> Object: return self def __rpow__(self, value: Any) -> Object: return self AR_b: np.ndarray[Any, np.dtype[np.bool_]] = np.array([True]) AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32) AR_i: np.ndarray[Any, np.dtype[np.int64]] = np.array([1]) AR_f: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0]) AR_c: np.ndarray[Any, np.dtype[np.complex128]] = np.array([1j]) AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64(1, "D")]) AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64(1, "D")]) AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([Object()]) AR_LIKE_b = [True] AR_LIKE_u = [np.uint32(1)] AR_LIKE_i = [1] AR_LIKE_f = [1.0] AR_LIKE_c = [1j] AR_LIKE_m = [np.timedelta64(1, "D")] AR_LIKE_M = [np.datetime64(1, "D")] AR_LIKE_O = [Object()] # Array subtractions AR_b - AR_LIKE_u AR_b - AR_LIKE_i AR_b - AR_LIKE_f AR_b - AR_LIKE_c AR_b - AR_LIKE_m AR_b - AR_LIKE_O AR_LIKE_u - AR_b AR_LIKE_i - AR_b AR_LIKE_f - AR_b AR_LIKE_c - AR_b AR_LIKE_m - AR_b AR_LIKE_M - AR_b AR_LIKE_O - AR_b AR_u - AR_LIKE_b AR_u - AR_LIKE_u AR_u - AR_LIKE_i AR_u - AR_LIKE_f AR_u - AR_LIKE_c AR_u - AR_LIKE_m AR_u - AR_LIKE_O AR_LIKE_b - AR_u AR_LIKE_u - AR_u AR_LIKE_i - AR_u AR_LIKE_f - AR_u AR_LIKE_c - AR_u AR_LIKE_m - AR_u AR_LIKE_M - AR_u AR_LIKE_O - AR_u AR_i - AR_LIKE_b AR_i - AR_LIKE_u AR_i - AR_LIKE_i AR_i - AR_LIKE_f AR_i - AR_LIKE_c AR_i - AR_LIKE_m AR_i - AR_LIKE_O AR_LIKE_b - AR_i AR_LIKE_u - AR_i AR_LIKE_i - AR_i AR_LIKE_f - AR_i AR_LIKE_c - AR_i AR_LIKE_m - AR_i AR_LIKE_M - AR_i AR_LIKE_O - AR_i AR_f - AR_LIKE_b AR_f - AR_LIKE_u AR_f - AR_LIKE_i AR_f - AR_LIKE_f AR_f - AR_LIKE_c AR_f - AR_LIKE_O AR_LIKE_b - AR_f AR_LIKE_u - AR_f AR_LIKE_i - AR_f AR_LIKE_f - AR_f AR_LIKE_c - AR_f AR_LIKE_O - AR_f AR_c - AR_LIKE_b AR_c - AR_LIKE_u AR_c - AR_LIKE_i AR_c - AR_LIKE_f AR_c - AR_LIKE_c AR_c - AR_LIKE_O AR_LIKE_b - AR_c AR_LIKE_u - AR_c AR_LIKE_i - AR_c AR_LIKE_f - AR_c AR_LIKE_c - AR_c AR_LIKE_O - AR_c AR_m - AR_LIKE_b AR_m - AR_LIKE_u AR_m - AR_LIKE_i AR_m - AR_LIKE_m AR_LIKE_b - AR_m AR_LIKE_u - AR_m AR_LIKE_i - AR_m AR_LIKE_m - AR_m AR_LIKE_M - AR_m AR_M - AR_LIKE_b AR_M - AR_LIKE_u AR_M - AR_LIKE_i AR_M - AR_LIKE_m AR_M - AR_LIKE_M AR_LIKE_M - AR_M AR_O - AR_LIKE_b AR_O - AR_LIKE_u AR_O - AR_LIKE_i AR_O - AR_LIKE_f AR_O - AR_LIKE_c AR_O - AR_LIKE_O AR_LIKE_b - AR_O AR_LIKE_u - AR_O AR_LIKE_i - AR_O AR_LIKE_f - AR_O AR_LIKE_c - AR_O AR_LIKE_O - AR_O AR_u += AR_b AR_u += AR_u AR_u += 1 # Allowed during runtime as long as the object is 0D and >=0 # Array floor division AR_b // AR_LIKE_b AR_b // AR_LIKE_u AR_b // AR_LIKE_i AR_b // AR_LIKE_f AR_b // AR_LIKE_O AR_LIKE_b // AR_b AR_LIKE_u // AR_b AR_LIKE_i // AR_b AR_LIKE_f // AR_b AR_LIKE_O // AR_b AR_u // AR_LIKE_b AR_u // AR_LIKE_u AR_u // AR_LIKE_i AR_u // AR_LIKE_f AR_u // AR_LIKE_O AR_LIKE_b // AR_u AR_LIKE_u // AR_u AR_LIKE_i // AR_u AR_LIKE_f // AR_u AR_LIKE_m // AR_u AR_LIKE_O // AR_u AR_i // AR_LIKE_b AR_i // AR_LIKE_u AR_i // AR_LIKE_i AR_i // AR_LIKE_f AR_i // AR_LIKE_O AR_LIKE_b // AR_i AR_LIKE_u // AR_i AR_LIKE_i // AR_i AR_LIKE_f // AR_i AR_LIKE_m // AR_i AR_LIKE_O // AR_i AR_f // AR_LIKE_b AR_f // AR_LIKE_u AR_f // AR_LIKE_i AR_f // AR_LIKE_f AR_f // AR_LIKE_O AR_LIKE_b // AR_f AR_LIKE_u // AR_f AR_LIKE_i // AR_f AR_LIKE_f // AR_f AR_LIKE_m // AR_f AR_LIKE_O // AR_f AR_m // AR_LIKE_u AR_m // AR_LIKE_i AR_m // AR_LIKE_f AR_m // AR_LIKE_m AR_LIKE_m // AR_m AR_O // AR_LIKE_b AR_O // AR_LIKE_u AR_O // AR_LIKE_i AR_O // AR_LIKE_f AR_O // AR_LIKE_O AR_LIKE_b // AR_O AR_LIKE_u // AR_O AR_LIKE_i // AR_O AR_LIKE_f // AR_O AR_LIKE_O // AR_O # Inplace multiplication AR_b *= AR_LIKE_b AR_u *= AR_LIKE_b AR_u *= AR_LIKE_u AR_i *= AR_LIKE_b AR_i *= AR_LIKE_u AR_i *= AR_LIKE_i AR_f *= AR_LIKE_b AR_f *= AR_LIKE_u AR_f *= AR_LIKE_i AR_f *= AR_LIKE_f AR_c *= AR_LIKE_b AR_c *= AR_LIKE_u AR_c *= AR_LIKE_i AR_c *= AR_LIKE_f AR_c *= AR_LIKE_c AR_m *= AR_LIKE_b AR_m *= AR_LIKE_u AR_m *= AR_LIKE_i AR_m *= AR_LIKE_f AR_O *= AR_LIKE_b AR_O *= AR_LIKE_u AR_O *= AR_LIKE_i AR_O *= AR_LIKE_f AR_O *= AR_LIKE_c AR_O *= AR_LIKE_O # Inplace power AR_u **= AR_LIKE_b AR_u **= AR_LIKE_u AR_i **= AR_LIKE_b AR_i **= AR_LIKE_u AR_i **= AR_LIKE_i AR_f **= AR_LIKE_b AR_f **= AR_LIKE_u AR_f **= AR_LIKE_i AR_f **= AR_LIKE_f AR_c **= AR_LIKE_b AR_c **= AR_LIKE_u AR_c **= AR_LIKE_i AR_c **= AR_LIKE_f AR_c **= AR_LIKE_c AR_O **= AR_LIKE_b AR_O **= AR_LIKE_u AR_O **= AR_LIKE_i AR_O **= AR_LIKE_f AR_O **= AR_LIKE_c AR_O **= AR_LIKE_O # unary ops -c16 -c8 -f8 -f4 -i8 -i4 with pytest.warns(RuntimeWarning): -u8 -u4 -td -AR_f +c16 +c8 +f8 +f4 +i8 +i4 +u8 +u4 +td +AR_f abs(c16) abs(c8) abs(f8) abs(f4) abs(i8) abs(i4) abs(u8) abs(u4) abs(td) abs(b_) abs(AR_f) # Time structures dt + td dt + i dt + i4 dt + i8 dt - dt dt - i dt - i4 dt - i8 td + td td + i td + i4 td + i8 td - td td - i td - i4 td - i8 td / f td / f4 td / f8 td / td td // td td % td # boolean b_ / b b_ / b_ b_ / i b_ / i8 b_ / i4 b_ / u8 b_ / u4 b_ / f b_ / f8 b_ / f4 b_ / c b_ / c16 b_ / c8 b / b_ b_ / b_ i / b_ i8 / b_ i4 / b_ u8 / b_ u4 / b_ f / b_ f8 / b_ f4 / b_ c / b_ c16 / b_ c8 / b_ # Complex c16 + c16 c16 + f8 c16 + i8 c16 + c8 c16 + f4 c16 + i4 c16 + b_ c16 + b c16 + c c16 + f c16 + i c16 + AR_f c16 + c16 f8 + c16 i8 + c16 c8 + c16 f4 + c16 i4 + c16 b_ + c16 b + c16 c + c16 f + c16 i + c16 AR_f + c16 c8 + c16 c8 + f8 c8 + i8 c8 + c8 c8 + f4 c8 + i4 c8 + b_ c8 + b c8 + c c8 + f c8 + i c8 + AR_f c16 + c8 f8 + c8 i8 + c8 c8 + c8 f4 + c8 i4 + c8 b_ + c8 b + c8 c + c8 f + c8 i + c8 AR_f + c8 # Float f8 + f8 f8 + i8 f8 + f4 f8 + i4 f8 + b_ f8 + b f8 + c f8 + f f8 + i f8 + AR_f f8 + f8 i8 + f8 f4 + f8 i4 + f8 b_ + f8 b + f8 c + f8 f + f8 i + f8 AR_f + f8 f4 + f8 f4 + i8 f4 + f4 f4 + i4 f4 + b_ f4 + b f4 + c f4 + f f4 + i f4 + AR_f f8 + f4 i8 + f4 f4 + f4 i4 + f4 b_ + f4 b + f4 c + f4 f + f4 i + f4 AR_f + f4 # Int i8 + i8 i8 + u8 i8 + i4 i8 + u4 i8 + b_ i8 + b i8 + c i8 + f i8 + i i8 + AR_f u8 + u8 u8 + i4 u8 + u4 u8 + b_ u8 + b u8 + c u8 + f u8 + i u8 + AR_f i8 + i8 u8 + i8 i4 + i8 u4 + i8 b_ + i8 b + i8 c + i8 f + i8 i + i8 AR_f + i8 u8 + u8 i4 + u8 u4 + u8 b_ + u8 b + u8 c + u8 f + u8 i + u8 AR_f + u8 i4 + i8 i4 + i4 i4 + i i4 + b_ i4 + b i4 + AR_f u4 + i8 u4 + i4 u4 + u8 u4 + u4 u4 + i u4 + b_ u4 + b u4 + AR_f i8 + i4 i4 + i4 i + i4 b_ + i4 b + i4 AR_f + i4 i8 + u4 i4 + u4 u8 + u4 u4 + u4 b_ + u4 b + u4 i + u4 AR_f + u4 PKIZGhs s data/pass/array_constructors.pynu[import sys from typing import Any import numpy as np class Index: def __index__(self) -> int: return 0 class SubClass(np.ndarray): pass def func(i: int, j: int, **kwargs: Any) -> SubClass: return B i8 = np.int64(1) A = np.array([1]) B = A.view(SubClass).copy() B_stack = np.array([[1], [1]]).view(SubClass) C = [1] np.ndarray(Index()) np.ndarray([Index()]) np.array(1, dtype=float) np.array(1, copy=False) np.array(1, order='F') np.array(1, order=None) np.array(1, subok=True) np.array(1, ndmin=3) np.array(1, str, copy=True, order='C', subok=False, ndmin=2) np.asarray(A) np.asarray(B) np.asarray(C) np.asanyarray(A) np.asanyarray(B) np.asanyarray(B, dtype=int) np.asanyarray(C) np.ascontiguousarray(A) np.ascontiguousarray(B) np.ascontiguousarray(C) np.asfortranarray(A) np.asfortranarray(B) np.asfortranarray(C) np.require(A) np.require(B) np.require(B, dtype=int) np.require(B, requirements=None) np.require(B, requirements="E") np.require(B, requirements=["ENSUREARRAY"]) np.require(B, requirements={"F", "E"}) np.require(B, requirements=["C", "OWNDATA"]) np.require(B, requirements="W") np.require(B, requirements="A") np.require(C) np.linspace(0, 2) np.linspace(0.5, [0, 1, 2]) np.linspace([0, 1, 2], 3) np.linspace(0j, 2) np.linspace(0, 2, num=10) np.linspace(0, 2, endpoint=True) np.linspace(0, 2, retstep=True) np.linspace(0j, 2j, retstep=True) np.linspace(0, 2, dtype=bool) np.linspace([0, 1], [2, 3], axis=Index()) np.logspace(0, 2, base=2) np.logspace(0, 2, base=2) np.logspace(0, 2, base=[1j, 2j], num=2) np.geomspace(1, 2) np.zeros_like(A) np.zeros_like(C) np.zeros_like(B) np.zeros_like(B, dtype=np.int64) np.ones_like(A) np.ones_like(C) np.ones_like(B) np.ones_like(B, dtype=np.int64) np.empty_like(A) np.empty_like(C) np.empty_like(B) np.empty_like(B, dtype=np.int64) np.full_like(A, i8) np.full_like(C, i8) np.full_like(B, i8) np.full_like(B, i8, dtype=np.int64) np.ones(1) np.ones([1, 1, 1]) np.full(1, i8) np.full([1, 1, 1], i8) np.indices([1, 2, 3]) np.indices([1, 2, 3], sparse=True) np.fromfunction(func, (3, 5)) np.identity(10) np.atleast_1d(C) np.atleast_1d(A) np.atleast_1d(C, C) np.atleast_1d(C, A) np.atleast_1d(A, A) np.atleast_2d(C) np.atleast_3d(C) np.vstack([C, C]) np.vstack([C, A]) np.vstack([A, A]) np.hstack([C, C]) np.stack([C, C]) np.stack([C, C], axis=0) np.stack([C, C], out=B_stack) np.block([[C, C], [C, C]]) np.block(A) PKIZҸodata/pass/array_like.pynu[from __future__ import annotations from typing import Any import numpy as np from numpy._typing import ArrayLike, _SupportsArray x1: ArrayLike = True x2: ArrayLike = 5 x3: ArrayLike = 1.0 x4: ArrayLike = 1 + 1j x5: ArrayLike = np.int8(1) x6: ArrayLike = np.float64(1) x7: ArrayLike = np.complex128(1) x8: ArrayLike = np.array([1, 2, 3]) x9: ArrayLike = [1, 2, 3] x10: ArrayLike = (1, 2, 3) x11: ArrayLike = "foo" x12: ArrayLike = memoryview(b'foo') class A: def __array__(self, dtype: None | np.dtype[Any] = None) -> np.ndarray: return np.array([1, 2, 3]) x13: ArrayLike = A() scalar: _SupportsArray = np.int64(1) scalar.__array__() array: _SupportsArray = np.array(1) array.__array__() a: _SupportsArray = A() a.__array__() a.__array__() # Escape hatch for when you mean to make something like an object # array. object_array_scalar: Any = (i for i in range(10)) np.array(object_array_scalar) PKIZUEdata/pass/arrayprint.pynu[import numpy as np AR = np.arange(10) AR.setflags(write=False) with np.printoptions(): np.set_printoptions( precision=1, threshold=2, edgeitems=3, linewidth=4, suppress=False, nanstr="Bob", infstr="Bill", formatter={}, sign="+", floatmode="unique", ) np.get_printoptions() str(AR) np.array2string( AR, max_line_width=5, precision=2, suppress_small=True, separator=";", prefix="test", threshold=5, floatmode="fixed", suffix="?", legacy="1.13", ) np.format_float_scientific(1, precision=5) np.format_float_positional(1, trim="k") np.array_repr(AR) np.array_str(AR) PKIZg,data/pass/arrayterator.pynu[ from __future__ import annotations from typing import Any import numpy as np AR_i8: np.ndarray[Any, np.dtype[np.int_]] = np.arange(10) ar_iter = np.lib.Arrayterator(AR_i8) ar_iter.var ar_iter.buf_size ar_iter.start ar_iter.stop ar_iter.step ar_iter.shape ar_iter.flat ar_iter.__array__() for i in ar_iter: pass ar_iter[0] ar_iter[...] ar_iter[:] ar_iter[0, 0, 0] ar_iter[..., 0, :] PKIZD,data/pass/bitwise_ops.pynu[import numpy as np i8 = np.int64(1) u8 = np.uint64(1) i4 = np.int32(1) u4 = np.uint32(1) b_ = np.bool_(1) b = bool(1) i = int(1) AR = np.array([0, 1, 2], dtype=np.int32) AR.setflags(write=False) i8 << i8 i8 >> i8 i8 | i8 i8 ^ i8 i8 & i8 i8 << AR i8 >> AR i8 | AR i8 ^ AR i8 & AR i4 << i4 i4 >> i4 i4 | i4 i4 ^ i4 i4 & i4 i8 << i4 i8 >> i4 i8 | i4 i8 ^ i4 i8 & i4 i8 << i i8 >> i i8 | i i8 ^ i i8 & i i8 << b_ i8 >> b_ i8 | b_ i8 ^ b_ i8 & b_ i8 << b i8 >> b i8 | b i8 ^ b i8 & b u8 << u8 u8 >> u8 u8 | u8 u8 ^ u8 u8 & u8 u8 << AR u8 >> AR u8 | AR u8 ^ AR u8 & AR u4 << u4 u4 >> u4 u4 | u4 u4 ^ u4 u4 & u4 u4 << i4 u4 >> i4 u4 | i4 u4 ^ i4 u4 & i4 u4 << i u4 >> i u4 | i u4 ^ i u4 & i u8 << b_ u8 >> b_ u8 | b_ u8 ^ b_ u8 & b_ u8 << b u8 >> b u8 | b u8 ^ b u8 & b b_ << b_ b_ >> b_ b_ | b_ b_ ^ b_ b_ & b_ b_ << AR b_ >> AR b_ | AR b_ ^ AR b_ & AR b_ << b b_ >> b b_ | b b_ ^ b b_ & b b_ << i b_ >> i b_ | i b_ ^ i b_ & i ~i8 ~i4 ~u8 ~u4 ~b_ ~AR PKIZ data/pass/comparisons.pynu[from __future__ import annotations from typing import Any import numpy as np c16 = np.complex128() f8 = np.float64() i8 = np.int64() u8 = np.uint64() c8 = np.complex64() f4 = np.float32() i4 = np.int32() u4 = np.uint32() dt = np.datetime64(0, "D") td = np.timedelta64(0, "D") b_ = np.bool_() b = bool() c = complex() f = float() i = int() SEQ = (0, 1, 2, 3, 4) AR_b: np.ndarray[Any, np.dtype[np.bool_]] = np.array([True]) AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32) AR_i: np.ndarray[Any, np.dtype[np.int_]] = np.array([1]) AR_f: np.ndarray[Any, np.dtype[np.float_]] = np.array([1.0]) AR_c: np.ndarray[Any, np.dtype[np.complex_]] = np.array([1.0j]) AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64("1")]) AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64("1")]) AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([1], dtype=object) # Arrays AR_b > AR_b AR_b > AR_u AR_b > AR_i AR_b > AR_f AR_b > AR_c AR_u > AR_b AR_u > AR_u AR_u > AR_i AR_u > AR_f AR_u > AR_c AR_i > AR_b AR_i > AR_u AR_i > AR_i AR_i > AR_f AR_i > AR_c AR_f > AR_b AR_f > AR_u AR_f > AR_i AR_f > AR_f AR_f > AR_c AR_c > AR_b AR_c > AR_u AR_c > AR_i AR_c > AR_f AR_c > AR_c AR_m > AR_b AR_m > AR_u AR_m > AR_i AR_b > AR_m AR_u > AR_m AR_i > AR_m AR_M > AR_M AR_O > AR_O 1 > AR_O AR_O > 1 # Time structures dt > dt td > td td > i td > i4 td > i8 td > AR_i td > SEQ # boolean b_ > b b_ > b_ b_ > i b_ > i8 b_ > i4 b_ > u8 b_ > u4 b_ > f b_ > f8 b_ > f4 b_ > c b_ > c16 b_ > c8 b_ > AR_i b_ > SEQ # Complex c16 > c16 c16 > f8 c16 > i8 c16 > c8 c16 > f4 c16 > i4 c16 > b_ c16 > b c16 > c c16 > f c16 > i c16 > AR_i c16 > SEQ c16 > c16 f8 > c16 i8 > c16 c8 > c16 f4 > c16 i4 > c16 b_ > c16 b > c16 c > c16 f > c16 i > c16 AR_i > c16 SEQ > c16 c8 > c16 c8 > f8 c8 > i8 c8 > c8 c8 > f4 c8 > i4 c8 > b_ c8 > b c8 > c c8 > f c8 > i c8 > AR_i c8 > SEQ c16 > c8 f8 > c8 i8 > c8 c8 > c8 f4 > c8 i4 > c8 b_ > c8 b > c8 c > c8 f > c8 i > c8 AR_i > c8 SEQ > c8 # Float f8 > f8 f8 > i8 f8 > f4 f8 > i4 f8 > b_ f8 > b f8 > c f8 > f f8 > i f8 > AR_i f8 > SEQ f8 > f8 i8 > f8 f4 > f8 i4 > f8 b_ > f8 b > f8 c > f8 f > f8 i > f8 AR_i > f8 SEQ > f8 f4 > f8 f4 > i8 f4 > f4 f4 > i4 f4 > b_ f4 > b f4 > c f4 > f f4 > i f4 > AR_i f4 > SEQ f8 > f4 i8 > f4 f4 > f4 i4 > f4 b_ > f4 b > f4 c > f4 f > f4 i > f4 AR_i > f4 SEQ > f4 # Int i8 > i8 i8 > u8 i8 > i4 i8 > u4 i8 > b_ i8 > b i8 > c i8 > f i8 > i i8 > AR_i i8 > SEQ u8 > u8 u8 > i4 u8 > u4 u8 > b_ u8 > b u8 > c u8 > f u8 > i u8 > AR_i u8 > SEQ i8 > i8 u8 > i8 i4 > i8 u4 > i8 b_ > i8 b > i8 c > i8 f > i8 i > i8 AR_i > i8 SEQ > i8 u8 > u8 i4 > u8 u4 > u8 b_ > u8 b > u8 c > u8 f > u8 i > u8 AR_i > u8 SEQ > u8 i4 > i8 i4 > i4 i4 > i i4 > b_ i4 > b i4 > AR_i i4 > SEQ u4 > i8 u4 > i4 u4 > u8 u4 > u4 u4 > i u4 > b_ u4 > b u4 > AR_i u4 > SEQ i8 > i4 i4 > i4 i > i4 b_ > i4 b > i4 AR_i > i4 SEQ > i4 i8 > u4 i4 > u4 u8 > u4 u4 > u4 b_ > u4 b > u4 i > u4 AR_i > u4 SEQ > u4 PKIZ--data/pass/dtype.pynu[import numpy as np dtype_obj = np.dtype(np.str_) void_dtype_obj = np.dtype([("f0", np.float64), ("f1", np.float32)]) np.dtype(dtype=np.int64) np.dtype(int) np.dtype("int") np.dtype(None) np.dtype((int, 2)) np.dtype((int, (1,))) np.dtype({"names": ["a", "b"], "formats": [int, float]}) np.dtype({"names": ["a"], "formats": [int], "titles": [object]}) np.dtype({"names": ["a"], "formats": [int], "titles": [object()]}) np.dtype([("name", np.str_, 16), ("grades", np.float64, (2,)), ("age", "int32")]) np.dtype( { "names": ["a", "b"], "formats": [int, float], "itemsize": 9, "aligned": False, "titles": ["x", "y"], "offsets": [0, 1], } ) np.dtype((np.float_, float)) class Test: dtype = np.dtype(float) np.dtype(Test()) # Methods and attributes dtype_obj.base dtype_obj.subdtype dtype_obj.newbyteorder() dtype_obj.type dtype_obj.name dtype_obj.names dtype_obj * 0 dtype_obj * 2 0 * dtype_obj 2 * dtype_obj void_dtype_obj["f0"] void_dtype_obj[0] void_dtype_obj[["f0", "f1"]] void_dtype_obj[["f0"]] PKIZNZZdata/pass/einsumfunc.pynu[from __future__ import annotations from typing import Any import numpy as np AR_LIKE_b = [True, True, True] AR_LIKE_u = [np.uint32(1), np.uint32(2), np.uint32(3)] AR_LIKE_i = [1, 2, 3] AR_LIKE_f = [1.0, 2.0, 3.0] AR_LIKE_c = [1j, 2j, 3j] AR_LIKE_U = ["1", "2", "3"] OUT_f: np.ndarray[Any, np.dtype[np.float64]] = np.empty(3, dtype=np.float64) OUT_c: np.ndarray[Any, np.dtype[np.complex128]] = np.empty(3, dtype=np.complex128) np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_b) np.einsum("i,i->i", AR_LIKE_u, AR_LIKE_u) np.einsum("i,i->i", AR_LIKE_i, AR_LIKE_i) np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f) np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c) np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_i) np.einsum("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c) np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, dtype="c16") np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe") np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, out=OUT_c) np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=int, casting="unsafe", out=OUT_f) np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_b) np.einsum_path("i,i->i", AR_LIKE_u, AR_LIKE_u) np.einsum_path("i,i->i", AR_LIKE_i, AR_LIKE_i) np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f) np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c) np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i) np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c) PKIZq6data/pass/flatiter.pynu[import numpy as np a = np.empty((2, 2)).flat a.base a.copy() a.coords a.index iter(a) next(a) a[0] a[[0, 1, 2]] a[...] a[:] a.__array__() a.__array__(np.dtype(np.float64)) PKIZV䶞data/pass/fromnumeric.pynu["""Tests for :mod:`numpy.core.fromnumeric`.""" import numpy as np A = np.array(True, ndmin=2, dtype=bool) B = np.array(1.0, ndmin=2, dtype=np.float32) A.setflags(write=False) B.setflags(write=False) a = np.bool_(True) b = np.float32(1.0) c = 1.0 d = np.array(1.0, dtype=np.float32) # writeable np.take(a, 0) np.take(b, 0) np.take(c, 0) np.take(A, 0) np.take(B, 0) np.take(A, [0]) np.take(B, [0]) np.reshape(a, 1) np.reshape(b, 1) np.reshape(c, 1) np.reshape(A, 1) np.reshape(B, 1) np.choose(a, [True, True]) np.choose(A, [1.0, 1.0]) np.repeat(a, 1) np.repeat(b, 1) np.repeat(c, 1) np.repeat(A, 1) np.repeat(B, 1) np.swapaxes(A, 0, 0) np.swapaxes(B, 0, 0) np.transpose(a) np.transpose(b) np.transpose(c) np.transpose(A) np.transpose(B) np.partition(a, 0, axis=None) np.partition(b, 0, axis=None) np.partition(c, 0, axis=None) np.partition(A, 0) np.partition(B, 0) np.argpartition(a, 0) np.argpartition(b, 0) np.argpartition(c, 0) np.argpartition(A, 0) np.argpartition(B, 0) np.sort(A, 0) np.sort(B, 0) np.argsort(A, 0) np.argsort(B, 0) np.argmax(A) np.argmax(B) np.argmax(A, axis=0) np.argmax(B, axis=0) np.argmin(A) np.argmin(B) np.argmin(A, axis=0) np.argmin(B, axis=0) np.searchsorted(A[0], 0) np.searchsorted(B[0], 0) np.searchsorted(A[0], [0]) np.searchsorted(B[0], [0]) np.resize(a, (5, 5)) np.resize(b, (5, 5)) np.resize(c, (5, 5)) np.resize(A, (5, 5)) np.resize(B, (5, 5)) np.squeeze(a) np.squeeze(b) np.squeeze(c) np.squeeze(A) np.squeeze(B) np.diagonal(A) np.diagonal(B) np.trace(A) np.trace(B) np.ravel(a) np.ravel(b) np.ravel(c) np.ravel(A) np.ravel(B) np.nonzero(A) np.nonzero(B) np.shape(a) np.shape(b) np.shape(c) np.shape(A) np.shape(B) np.compress([True], a) np.compress([True], b) np.compress([True], c) np.compress([True], A) np.compress([True], B) np.clip(a, 0, 1.0) np.clip(b, -1, 1) np.clip(a, 0, None) np.clip(b, None, 1) np.clip(c, 0, 1) np.clip(A, 0, 1) np.clip(B, 0, 1) np.clip(B, [0, 1], [1, 2]) np.sum(a) np.sum(b) np.sum(c) np.sum(A) np.sum(B) np.sum(A, axis=0) np.sum(B, axis=0) np.all(a) np.all(b) np.all(c) np.all(A) np.all(B) np.all(A, axis=0) np.all(B, axis=0) np.all(A, keepdims=True) np.all(B, keepdims=True) np.any(a) np.any(b) np.any(c) np.any(A) np.any(B) np.any(A, axis=0) np.any(B, axis=0) np.any(A, keepdims=True) np.any(B, keepdims=True) np.cumsum(a) np.cumsum(b) np.cumsum(c) np.cumsum(A) np.cumsum(B) np.ptp(b) np.ptp(c) np.ptp(B) np.ptp(B, axis=0) np.ptp(B, keepdims=True) np.amax(a) np.amax(b) np.amax(c) np.amax(A) np.amax(B) np.amax(A, axis=0) np.amax(B, axis=0) np.amax(A, keepdims=True) np.amax(B, keepdims=True) np.amin(a) np.amin(b) np.amin(c) np.amin(A) np.amin(B) np.amin(A, axis=0) np.amin(B, axis=0) np.amin(A, keepdims=True) np.amin(B, keepdims=True) np.prod(a) np.prod(b) np.prod(c) np.prod(A) np.prod(B) np.prod(a, dtype=None) np.prod(A, dtype=None) np.prod(A, axis=0) np.prod(B, axis=0) np.prod(A, keepdims=True) np.prod(B, keepdims=True) np.prod(b, out=d) np.prod(B, out=d) np.cumprod(a) np.cumprod(b) np.cumprod(c) np.cumprod(A) np.cumprod(B) np.ndim(a) np.ndim(b) np.ndim(c) np.ndim(A) np.ndim(B) np.size(a) np.size(b) np.size(c) np.size(A) np.size(B) np.around(a) np.around(b) np.around(c) np.around(A) np.around(B) np.mean(a) np.mean(b) np.mean(c) np.mean(A) np.mean(B) np.mean(A, axis=0) np.mean(B, axis=0) np.mean(A, keepdims=True) np.mean(B, keepdims=True) np.mean(b, out=d) np.mean(B, out=d) np.std(a) np.std(b) np.std(c) np.std(A) np.std(B) np.std(A, axis=0) np.std(B, axis=0) np.std(A, keepdims=True) np.std(B, keepdims=True) np.std(b, out=d) np.std(B, out=d) np.var(a) np.var(b) np.var(c) np.var(A) np.var(B) np.var(A, axis=0) np.var(B, axis=0) np.var(A, keepdims=True) np.var(B, keepdims=True) np.var(b, out=d) np.var(B, out=d) PKIZYdata/pass/index_tricks.pynu[from __future__ import annotations from typing import Any import numpy as np AR_LIKE_b = [[True, True], [True, True]] AR_LIKE_i = [[1, 2], [3, 4]] AR_LIKE_f = [[1.0, 2.0], [3.0, 4.0]] AR_LIKE_U = [["1", "2"], ["3", "4"]] AR_i8: np.ndarray[Any, np.dtype[np.int64]] = np.array(AR_LIKE_i, dtype=np.int64) np.ndenumerate(AR_i8) np.ndenumerate(AR_LIKE_f) np.ndenumerate(AR_LIKE_U) np.ndenumerate(AR_i8).iter np.ndenumerate(AR_LIKE_f).iter np.ndenumerate(AR_LIKE_U).iter next(np.ndenumerate(AR_i8)) next(np.ndenumerate(AR_LIKE_f)) next(np.ndenumerate(AR_LIKE_U)) iter(np.ndenumerate(AR_i8)) iter(np.ndenumerate(AR_LIKE_f)) iter(np.ndenumerate(AR_LIKE_U)) iter(np.ndindex(1, 2, 3)) next(np.ndindex(1, 2, 3)) np.unravel_index([22, 41, 37], (7, 6)) np.unravel_index([31, 41, 13], (7, 6), order='F') np.unravel_index(1621, (6, 7, 8, 9)) np.ravel_multi_index(AR_LIKE_i, (7, 6)) np.ravel_multi_index(AR_LIKE_i, (7, 6), order='F') np.ravel_multi_index(AR_LIKE_i, (4, 6), mode='clip') np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=('clip', 'wrap')) np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9)) np.mgrid[1:1:2] np.mgrid[1:1:2, None:10] np.ogrid[1:1:2] np.ogrid[1:1:2, None:10] np.index_exp[0:1] np.index_exp[0:1, None:3] np.index_exp[0, 0:1, ..., [0, 1, 3]] np.s_[0:1] np.s_[0:1, None:3] np.s_[0, 0:1, ..., [0, 1, 3]] np.ix_(AR_LIKE_b[0]) np.ix_(AR_LIKE_i[0], AR_LIKE_f[0]) np.ix_(AR_i8[0]) np.fill_diagonal(AR_i8, 5) np.diag_indices(4) np.diag_indices(2, 3) np.diag_indices_from(AR_i8) PKIZwdata/pass/lib_utils.pynu[from __future__ import annotations from io import StringIO import numpy as np FILE = StringIO() AR = np.arange(10, dtype=np.float64) def func(a: int) -> bool: ... np.deprecate(func) np.deprecate() np.deprecate_with_doc("test") np.deprecate_with_doc(None) np.byte_bounds(AR) np.byte_bounds(np.float64()) np.info(1, output=FILE) np.source(np.interp, output=FILE) np.lookfor("binary representation", output=FILE) PKIZ_[++data/pass/lib_version.pynu[from numpy.lib import NumpyVersion version = NumpyVersion("1.8.0") version.vstring version.version version.major version.minor version.bugfix version.pre_release version.is_devversion version == version version != version version < "1.8.0" version <= version version > version version >= "1.8.0" PKIZo??33data/pass/literal.pynu[from __future__ import annotations from functools import partial from collections.abc import Callable import pytest # type: ignore import numpy as np AR = np.array(0) AR.setflags(write=False) KACF = frozenset({None, "K", "A", "C", "F"}) ACF = frozenset({None, "A", "C", "F"}) CF = frozenset({None, "C", "F"}) order_list: list[tuple[frozenset, Callable]] = [ (KACF, partial(np.ndarray, 1)), (KACF, AR.tobytes), (KACF, partial(AR.astype, int)), (KACF, AR.copy), (ACF, partial(AR.reshape, 1)), (KACF, AR.flatten), (KACF, AR.ravel), (KACF, partial(np.array, 1)), (CF, partial(np.zeros, 1)), (CF, partial(np.ones, 1)), (CF, partial(np.empty, 1)), (CF, partial(np.full, 1, 1)), (KACF, partial(np.zeros_like, AR)), (KACF, partial(np.ones_like, AR)), (KACF, partial(np.empty_like, AR)), (KACF, partial(np.full_like, AR, 1)), (KACF, partial(np.add, 1, 1)), # i.e. np.ufunc.__call__ (ACF, partial(np.reshape, AR, 1)), (KACF, partial(np.ravel, AR)), (KACF, partial(np.asarray, 1)), (KACF, partial(np.asanyarray, 1)), ] for order_set, func in order_list: for order in order_set: func(order=order) invalid_orders = KACF - order_set for order in invalid_orders: with pytest.raises(ValueError): func(order=order) PKIZU$***data/pass/mod.pynu[import numpy as np f8 = np.float64(1) i8 = np.int64(1) u8 = np.uint64(1) f4 = np.float32(1) i4 = np.int32(1) u4 = np.uint32(1) td = np.timedelta64(1, "D") b_ = np.bool_(1) b = bool(1) f = float(1) i = int(1) AR = np.array([1], dtype=np.bool_) AR.setflags(write=False) AR2 = np.array([1], dtype=np.timedelta64) AR2.setflags(write=False) # Time structures td % td td % AR2 AR2 % td divmod(td, td) divmod(td, AR2) divmod(AR2, td) # Bool b_ % b b_ % i b_ % f b_ % b_ b_ % i8 b_ % u8 b_ % f8 b_ % AR divmod(b_, b) divmod(b_, i) divmod(b_, f) divmod(b_, b_) divmod(b_, i8) divmod(b_, u8) divmod(b_, f8) divmod(b_, AR) b % b_ i % b_ f % b_ b_ % b_ i8 % b_ u8 % b_ f8 % b_ AR % b_ divmod(b, b_) divmod(i, b_) divmod(f, b_) divmod(b_, b_) divmod(i8, b_) divmod(u8, b_) divmod(f8, b_) divmod(AR, b_) # int i8 % b i8 % i i8 % f i8 % i8 i8 % f8 i4 % i8 i4 % f8 i4 % i4 i4 % f4 i8 % AR divmod(i8, b) divmod(i8, i) divmod(i8, f) divmod(i8, i8) divmod(i8, f8) divmod(i8, i4) divmod(i8, f4) divmod(i4, i4) divmod(i4, f4) divmod(i8, AR) b % i8 i % i8 f % i8 i8 % i8 f8 % i8 i8 % i4 f8 % i4 i4 % i4 f4 % i4 AR % i8 divmod(b, i8) divmod(i, i8) divmod(f, i8) divmod(i8, i8) divmod(f8, i8) divmod(i4, i8) divmod(f4, i8) divmod(i4, i4) divmod(f4, i4) divmod(AR, i8) # float f8 % b f8 % i f8 % f i8 % f4 f4 % f4 f8 % AR divmod(f8, b) divmod(f8, i) divmod(f8, f) divmod(f8, f8) divmod(f8, f4) divmod(f4, f4) divmod(f8, AR) b % f8 i % f8 f % f8 f8 % f8 f8 % f8 f4 % f4 AR % f8 divmod(b, f8) divmod(i, f8) divmod(f, f8) divmod(f8, f8) divmod(f4, f8) divmod(f4, f4) divmod(AR, f8) PKIZU8SSdata/pass/modules.pynu[import numpy as np from numpy import f2py np.char np.ctypeslib np.emath np.fft np.lib np.linalg np.ma np.matrixlib np.polynomial np.random np.rec np.testing np.version np.lib.format np.lib.mixins np.lib.scimath np.lib.stride_tricks np.ma.extras np.polynomial.chebyshev np.polynomial.hermite np.polynomial.hermite_e np.polynomial.laguerre np.polynomial.legendre np.polynomial.polynomial np.__path__ np.__version__ np.__git_version__ np.__all__ np.char.__all__ np.ctypeslib.__all__ np.emath.__all__ np.lib.__all__ np.ma.__all__ np.random.__all__ np.rec.__all__ np.testing.__all__ f2py.__all__ PKIZR<[33data/pass/multiarray.pynu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] = np.array([1.0]) AR_i4 = np.array([1], dtype=np.int32) AR_u1 = np.array([1], dtype=np.uint8) AR_LIKE_f = [1.5] AR_LIKE_i = [1] b_f8 = np.broadcast(AR_f8) b_i4_f8_f8 = np.broadcast(AR_i4, AR_f8, AR_f8) next(b_f8) b_f8.reset() b_f8.index b_f8.iters b_f8.nd b_f8.ndim b_f8.numiter b_f8.shape b_f8.size next(b_i4_f8_f8) b_i4_f8_f8.reset() b_i4_f8_f8.ndim b_i4_f8_f8.index b_i4_f8_f8.iters b_i4_f8_f8.nd b_i4_f8_f8.numiter b_i4_f8_f8.shape b_i4_f8_f8.size np.inner(AR_f8, AR_i4) np.where([True, True, False]) np.where([True, True, False], 1, 0) np.lexsort([0, 1, 2]) np.can_cast(np.dtype("i8"), int) np.can_cast(AR_f8, "f8") np.can_cast(AR_f8, np.complex128, casting="unsafe") np.min_scalar_type([1]) np.min_scalar_type(AR_f8) np.result_type(int, AR_i4) np.result_type(AR_f8, AR_u1) np.result_type(AR_f8, np.complex128) np.dot(AR_LIKE_f, AR_i4) np.dot(AR_u1, 1) np.dot(1.5j, 1) np.dot(AR_u1, 1, out=AR_f8) np.vdot(AR_LIKE_f, AR_i4) np.vdot(AR_u1, 1) np.vdot(1.5j, 1) np.bincount(AR_i4) np.copyto(AR_f8, [1.6]) np.putmask(AR_f8, [True], 1.5) np.packbits(AR_i4) np.packbits(AR_u1) np.unpackbits(AR_u1) np.shares_memory(1, 2) np.shares_memory(AR_f8, AR_f8, max_work=1) np.may_share_memory(1, 2) np.may_share_memory(AR_f8, AR_f8, max_work=1) PKIZ TTZZdata/pass/ndarray_conversion.pynu[import os import tempfile import numpy as np nd = np.array([[1, 2], [3, 4]]) scalar_array = np.array(1) # item scalar_array.item() nd.item(1) nd.item(0, 1) nd.item((0, 1)) # tolist is pretty simple # itemset scalar_array.itemset(3) nd.itemset(3, 0) nd.itemset((0, 0), 3) # tobytes nd.tobytes() nd.tobytes("C") nd.tobytes(None) # tofile if os.name != "nt": with tempfile.NamedTemporaryFile(suffix=".txt") as tmp: nd.tofile(tmp.name) nd.tofile(tmp.name, "") nd.tofile(tmp.name, sep="") nd.tofile(tmp.name, "", "%s") nd.tofile(tmp.name, format="%s") nd.tofile(tmp) # dump is pretty simple # dumps is pretty simple # astype nd.astype("float") nd.astype(float) nd.astype(float, "K") nd.astype(float, order="K") nd.astype(float, "K", "unsafe") nd.astype(float, casting="unsafe") nd.astype(float, "K", "unsafe", True) nd.astype(float, subok=True) nd.astype(float, "K", "unsafe", True, True) nd.astype(float, copy=True) # byteswap nd.byteswap() nd.byteswap(True) # copy nd.copy() nd.copy("C") # view nd.view() nd.view(np.int64) nd.view(dtype=np.int64) nd.view(np.int64, np.matrix) nd.view(type=np.matrix) # getfield complex_array = np.array([[1 + 1j, 0], [0, 1 - 1j]], dtype=np.complex128) complex_array.getfield("float") complex_array.getfield(float) complex_array.getfield("float", 8) complex_array.getfield(float, offset=8) # setflags nd.setflags() nd.setflags(True) nd.setflags(write=True) nd.setflags(True, True) nd.setflags(write=True, align=True) nd.setflags(True, True, False) nd.setflags(write=True, align=True, uic=False) # fill is pretty simple PKIZV4 data/pass/ndarray_misc.pynu[""" Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods. More extensive tests are performed for the methods' function-based counterpart in `../from_numeric.py`. """ from __future__ import annotations import operator from typing import cast, Any import numpy as np class SubClass(np.ndarray): ... i4 = np.int32(1) A: np.ndarray[Any, np.dtype[np.int32]] = np.array([[1]], dtype=np.int32) B0 = np.empty((), dtype=np.int32).view(SubClass) B1 = np.empty((1,), dtype=np.int32).view(SubClass) B2 = np.empty((1, 1), dtype=np.int32).view(SubClass) C: np.ndarray[Any, np.dtype[np.int32]] = np.array([0, 1, 2], dtype=np.int32) D = np.ones(3).view(SubClass) i4.all() A.all() A.all(axis=0) A.all(keepdims=True) A.all(out=B0) i4.any() A.any() A.any(axis=0) A.any(keepdims=True) A.any(out=B0) i4.argmax() A.argmax() A.argmax(axis=0) A.argmax(out=B0) i4.argmin() A.argmin() A.argmin(axis=0) A.argmin(out=B0) i4.argsort() A.argsort() i4.choose([()]) _choices = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32) C.choose(_choices) C.choose(_choices, out=D) i4.clip(1) A.clip(1) A.clip(None, 1) A.clip(1, out=B2) A.clip(None, 1, out=B2) i4.compress([1]) A.compress([1]) A.compress([1], out=B1) i4.conj() A.conj() B0.conj() i4.conjugate() A.conjugate() B0.conjugate() i4.cumprod() A.cumprod() A.cumprod(out=B1) i4.cumsum() A.cumsum() A.cumsum(out=B1) i4.max() A.max() A.max(axis=0) A.max(keepdims=True) A.max(out=B0) i4.mean() A.mean() A.mean(axis=0) A.mean(keepdims=True) A.mean(out=B0) i4.min() A.min() A.min(axis=0) A.min(keepdims=True) A.min(out=B0) i4.newbyteorder() A.newbyteorder() B0.newbyteorder('|') i4.prod() A.prod() A.prod(axis=0) A.prod(keepdims=True) A.prod(out=B0) i4.ptp() A.ptp() A.ptp(axis=0) A.ptp(keepdims=True) A.astype(int).ptp(out=B0) i4.round() A.round() A.round(out=B2) i4.repeat(1) A.repeat(1) B0.repeat(1) i4.std() A.std() A.std(axis=0) A.std(keepdims=True) A.std(out=B0.astype(np.float64)) i4.sum() A.sum() A.sum(axis=0) A.sum(keepdims=True) A.sum(out=B0) i4.take(0) A.take(0) A.take([0]) A.take(0, out=B0) A.take([0], out=B1) i4.var() A.var() A.var(axis=0) A.var(keepdims=True) A.var(out=B0) A.argpartition([0]) A.diagonal() A.dot(1) A.dot(1, out=B2) A.nonzero() C.searchsorted(1) A.trace() A.trace(out=B0) void = cast(np.void, np.array(1, dtype=[("f", np.float64)]).take(0)) void.setfield(10, np.float64) A.item(0) C.item(0) A.ravel() C.ravel() A.flatten() C.flatten() A.reshape(1) C.reshape(3) int(np.array(1.0, dtype=np.float64)) int(np.array("1", dtype=np.str_)) float(np.array(1.0, dtype=np.float64)) float(np.array("1", dtype=np.str_)) complex(np.array(1.0, dtype=np.float64)) operator.index(np.array(1, dtype=np.int64)) PKIZ$,'data/pass/ndarray_shape_manipulation.pynu[import numpy as np nd1 = np.array([[1, 2], [3, 4]]) # reshape nd1.reshape(4) nd1.reshape(2, 2) nd1.reshape((2, 2)) nd1.reshape((2, 2), order="C") nd1.reshape(4, order="C") # resize nd1.resize() nd1.resize(4) nd1.resize(2, 2) nd1.resize((2, 2)) nd1.resize((2, 2), refcheck=True) nd1.resize(4, refcheck=True) nd2 = np.array([[1, 2], [3, 4]]) # transpose nd2.transpose() nd2.transpose(1, 0) nd2.transpose((1, 0)) # swapaxes nd2.swapaxes(0, 1) # flatten nd2.flatten() nd2.flatten("C") # ravel nd2.ravel() nd2.ravel("C") # squeeze nd2.squeeze() nd3 = np.array([[1, 2]]) nd3.squeeze(0) nd4 = np.array([[[1, 2]]]) nd4.squeeze((0, 1)) PKIZƫ\data/pass/numeric.pynu[""" Tests for :mod:`numpy.core.numeric`. Does not include tests which fall under ``array_constructors``. """ from __future__ import annotations import numpy as np class SubClass(np.ndarray): ... i8 = np.int64(1) A = np.arange(27).reshape(3, 3, 3) B: list[list[list[int]]] = A.tolist() C = np.empty((27, 27)).view(SubClass) np.count_nonzero(i8) np.count_nonzero(A) np.count_nonzero(B) np.count_nonzero(A, keepdims=True) np.count_nonzero(A, axis=0) np.isfortran(i8) np.isfortran(A) np.argwhere(i8) np.argwhere(A) np.flatnonzero(i8) np.flatnonzero(A) np.correlate(B[0][0], A.ravel(), mode="valid") np.correlate(A.ravel(), A.ravel(), mode="same") np.convolve(B[0][0], A.ravel(), mode="valid") np.convolve(A.ravel(), A.ravel(), mode="same") np.outer(i8, A) np.outer(B, A) np.outer(A, A) np.outer(A, A, out=C) np.tensordot(B, A) np.tensordot(A, A) np.tensordot(A, A, axes=0) np.tensordot(A, A, axes=(0, 1)) np.isscalar(i8) np.isscalar(A) np.isscalar(B) np.roll(A, 1) np.roll(A, (1, 2)) np.roll(B, 1) np.rollaxis(A, 0, 1) np.moveaxis(A, 0, 1) np.moveaxis(A, (0, 1), (1, 2)) np.cross(B, A) np.cross(A, A) np.indices([0, 1, 2]) np.indices([0, 1, 2], sparse=False) np.indices([0, 1, 2], sparse=True) np.binary_repr(1) np.base_repr(1) np.allclose(i8, A) np.allclose(B, A) np.allclose(A, A) np.isclose(i8, A) np.isclose(B, A) np.isclose(A, A) np.array_equal(i8, A) np.array_equal(B, A) np.array_equal(A, A) np.array_equiv(i8, A) np.array_equiv(B, A) np.array_equiv(A, A) PKIZ "data/pass/numerictypes.pynu[import numpy as np np.maximum_sctype("S8") np.maximum_sctype(object) np.issctype(object) np.issctype("S8") np.obj2sctype(list) np.obj2sctype(list, default=None) np.obj2sctype(list, default=np.bytes_) np.issubclass_(np.int32, int) np.issubclass_(np.float64, float) np.issubclass_(np.float64, (int, float)) np.issubsctype("int64", int) np.issubsctype(np.array([1]), np.array([1])) np.issubdtype("S1", np.bytes_) np.issubdtype(np.float64, np.float32) np.sctype2char("S1") np.sctype2char(list) np.cast[int] np.cast["i8"] np.cast[np.int64] np.nbytes[int] np.nbytes["i8"] np.nbytes[np.int64] np.ScalarType np.ScalarType[0] np.ScalarType[3] np.ScalarType[8] np.ScalarType[10] np.typecodes["Character"] np.typecodes["Complex"] np.typecodes["All"] PKIZ.@Vdata/pass/random.pynu[from __future__ import annotations from typing import Any import numpy as np SEED_NONE = None SEED_INT = 4579435749574957634658964293569 SEED_ARR: np.ndarray[Any, np.dtype[np.int64]] = np.array([1, 2, 3, 4], dtype=np.int64) SEED_ARRLIKE: list[int] = [1, 2, 3, 4] SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0) SEED_MT19937: np.random.MT19937 = np.random.MT19937(0) SEED_PCG64: np.random.PCG64 = np.random.PCG64(0) SEED_PHILOX: np.random.Philox = np.random.Philox(0) SEED_SFC64: np.random.SFC64 = np.random.SFC64(0) # default rng np.random.default_rng() np.random.default_rng(SEED_NONE) np.random.default_rng(SEED_INT) np.random.default_rng(SEED_ARR) np.random.default_rng(SEED_ARRLIKE) np.random.default_rng(SEED_SEED_SEQ) np.random.default_rng(SEED_MT19937) np.random.default_rng(SEED_PCG64) np.random.default_rng(SEED_PHILOX) np.random.default_rng(SEED_SFC64) # Seed Sequence np.random.SeedSequence(SEED_NONE) np.random.SeedSequence(SEED_INT) np.random.SeedSequence(SEED_ARR) np.random.SeedSequence(SEED_ARRLIKE) # Bit Generators np.random.MT19937(SEED_NONE) np.random.MT19937(SEED_INT) np.random.MT19937(SEED_ARR) np.random.MT19937(SEED_ARRLIKE) np.random.MT19937(SEED_SEED_SEQ) np.random.PCG64(SEED_NONE) np.random.PCG64(SEED_INT) np.random.PCG64(SEED_ARR) np.random.PCG64(SEED_ARRLIKE) np.random.PCG64(SEED_SEED_SEQ) np.random.Philox(SEED_NONE) np.random.Philox(SEED_INT) np.random.Philox(SEED_ARR) np.random.Philox(SEED_ARRLIKE) np.random.Philox(SEED_SEED_SEQ) np.random.SFC64(SEED_NONE) np.random.SFC64(SEED_INT) np.random.SFC64(SEED_ARR) np.random.SFC64(SEED_ARRLIKE) np.random.SFC64(SEED_SEED_SEQ) seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence(SEED_NONE) seed_seq.spawn(10) seed_seq.generate_state(3) seed_seq.generate_state(3, "u4") seed_seq.generate_state(3, "uint32") seed_seq.generate_state(3, "u8") seed_seq.generate_state(3, "uint64") seed_seq.generate_state(3, np.uint32) seed_seq.generate_state(3, np.uint64) def_gen: np.random.Generator = np.random.default_rng() D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1]) D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5]) D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9]) D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5]) I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_) I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_) D_arr_like_0p1: list[float] = [0.1] D_arr_like_0p5: list[float] = [0.5] D_arr_like_0p9: list[float] = [0.9] D_arr_like_1p5: list[float] = [1.5] I_arr_like_10: list[int] = [10] I_arr_like_20: list[int] = [20] D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]] D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like) S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32) D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1) def_gen.standard_normal() def_gen.standard_normal(dtype=np.float32) def_gen.standard_normal(dtype="float32") def_gen.standard_normal(dtype="double") def_gen.standard_normal(dtype=np.float64) def_gen.standard_normal(size=None) def_gen.standard_normal(size=1) def_gen.standard_normal(size=1, dtype=np.float32) def_gen.standard_normal(size=1, dtype="f4") def_gen.standard_normal(size=1, dtype="float32", out=S_out) def_gen.standard_normal(dtype=np.float32, out=S_out) def_gen.standard_normal(size=1, dtype=np.float64) def_gen.standard_normal(size=1, dtype="float64") def_gen.standard_normal(size=1, dtype="f8") def_gen.standard_normal(out=D_out) def_gen.standard_normal(size=1, dtype="float64") def_gen.standard_normal(size=1, dtype="float64", out=D_out) def_gen.random() def_gen.random(dtype=np.float32) def_gen.random(dtype="float32") def_gen.random(dtype="double") def_gen.random(dtype=np.float64) def_gen.random(size=None) def_gen.random(size=1) def_gen.random(size=1, dtype=np.float32) def_gen.random(size=1, dtype="f4") def_gen.random(size=1, dtype="float32", out=S_out) def_gen.random(dtype=np.float32, out=S_out) def_gen.random(size=1, dtype=np.float64) def_gen.random(size=1, dtype="float64") def_gen.random(size=1, dtype="f8") def_gen.random(out=D_out) def_gen.random(size=1, dtype="float64") def_gen.random(size=1, dtype="float64", out=D_out) def_gen.standard_cauchy() def_gen.standard_cauchy(size=None) def_gen.standard_cauchy(size=1) def_gen.standard_exponential() def_gen.standard_exponential(method="inv") def_gen.standard_exponential(dtype=np.float32) def_gen.standard_exponential(dtype="float32") def_gen.standard_exponential(dtype="double") def_gen.standard_exponential(dtype=np.float64) def_gen.standard_exponential(size=None) def_gen.standard_exponential(size=None, method="inv") def_gen.standard_exponential(size=1, method="inv") def_gen.standard_exponential(size=1, dtype=np.float32) def_gen.standard_exponential(size=1, dtype="f4", method="inv") def_gen.standard_exponential(size=1, dtype="float32", out=S_out) def_gen.standard_exponential(dtype=np.float32, out=S_out) def_gen.standard_exponential(size=1, dtype=np.float64, method="inv") def_gen.standard_exponential(size=1, dtype="float64") def_gen.standard_exponential(size=1, dtype="f8") def_gen.standard_exponential(out=D_out) def_gen.standard_exponential(size=1, dtype="float64") def_gen.standard_exponential(size=1, dtype="float64", out=D_out) def_gen.zipf(1.5) def_gen.zipf(1.5, size=None) def_gen.zipf(1.5, size=1) def_gen.zipf(D_arr_1p5) def_gen.zipf(D_arr_1p5, size=1) def_gen.zipf(D_arr_like_1p5) def_gen.zipf(D_arr_like_1p5, size=1) def_gen.weibull(0.5) def_gen.weibull(0.5, size=None) def_gen.weibull(0.5, size=1) def_gen.weibull(D_arr_0p5) def_gen.weibull(D_arr_0p5, size=1) def_gen.weibull(D_arr_like_0p5) def_gen.weibull(D_arr_like_0p5, size=1) def_gen.standard_t(0.5) def_gen.standard_t(0.5, size=None) def_gen.standard_t(0.5, size=1) def_gen.standard_t(D_arr_0p5) def_gen.standard_t(D_arr_0p5, size=1) def_gen.standard_t(D_arr_like_0p5) def_gen.standard_t(D_arr_like_0p5, size=1) def_gen.poisson(0.5) def_gen.poisson(0.5, size=None) def_gen.poisson(0.5, size=1) def_gen.poisson(D_arr_0p5) def_gen.poisson(D_arr_0p5, size=1) def_gen.poisson(D_arr_like_0p5) def_gen.poisson(D_arr_like_0p5, size=1) def_gen.power(0.5) def_gen.power(0.5, size=None) def_gen.power(0.5, size=1) def_gen.power(D_arr_0p5) def_gen.power(D_arr_0p5, size=1) def_gen.power(D_arr_like_0p5) def_gen.power(D_arr_like_0p5, size=1) def_gen.pareto(0.5) def_gen.pareto(0.5, size=None) def_gen.pareto(0.5, size=1) def_gen.pareto(D_arr_0p5) def_gen.pareto(D_arr_0p5, size=1) def_gen.pareto(D_arr_like_0p5) def_gen.pareto(D_arr_like_0p5, size=1) def_gen.chisquare(0.5) def_gen.chisquare(0.5, size=None) def_gen.chisquare(0.5, size=1) def_gen.chisquare(D_arr_0p5) def_gen.chisquare(D_arr_0p5, size=1) def_gen.chisquare(D_arr_like_0p5) def_gen.chisquare(D_arr_like_0p5, size=1) def_gen.exponential(0.5) def_gen.exponential(0.5, size=None) def_gen.exponential(0.5, size=1) def_gen.exponential(D_arr_0p5) def_gen.exponential(D_arr_0p5, size=1) def_gen.exponential(D_arr_like_0p5) def_gen.exponential(D_arr_like_0p5, size=1) def_gen.geometric(0.5) def_gen.geometric(0.5, size=None) def_gen.geometric(0.5, size=1) def_gen.geometric(D_arr_0p5) def_gen.geometric(D_arr_0p5, size=1) def_gen.geometric(D_arr_like_0p5) def_gen.geometric(D_arr_like_0p5, size=1) def_gen.logseries(0.5) def_gen.logseries(0.5, size=None) def_gen.logseries(0.5, size=1) def_gen.logseries(D_arr_0p5) def_gen.logseries(D_arr_0p5, size=1) def_gen.logseries(D_arr_like_0p5) def_gen.logseries(D_arr_like_0p5, size=1) def_gen.rayleigh(0.5) def_gen.rayleigh(0.5, size=None) def_gen.rayleigh(0.5, size=1) def_gen.rayleigh(D_arr_0p5) def_gen.rayleigh(D_arr_0p5, size=1) def_gen.rayleigh(D_arr_like_0p5) def_gen.rayleigh(D_arr_like_0p5, size=1) def_gen.standard_gamma(0.5) def_gen.standard_gamma(0.5, size=None) def_gen.standard_gamma(0.5, dtype="float32") def_gen.standard_gamma(0.5, size=None, dtype="float32") def_gen.standard_gamma(0.5, size=1) def_gen.standard_gamma(D_arr_0p5) def_gen.standard_gamma(D_arr_0p5, dtype="f4") def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out) def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out) def_gen.standard_gamma(D_arr_0p5, size=1) def_gen.standard_gamma(D_arr_like_0p5) def_gen.standard_gamma(D_arr_like_0p5, size=1) def_gen.standard_gamma(0.5, out=D_out) def_gen.standard_gamma(D_arr_like_0p5, out=D_out) def_gen.standard_gamma(D_arr_like_0p5, size=1) def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64) def_gen.vonmises(0.5, 0.5) def_gen.vonmises(0.5, 0.5, size=None) def_gen.vonmises(0.5, 0.5, size=1) def_gen.vonmises(D_arr_0p5, 0.5) def_gen.vonmises(0.5, D_arr_0p5) def_gen.vonmises(D_arr_0p5, 0.5, size=1) def_gen.vonmises(0.5, D_arr_0p5, size=1) def_gen.vonmises(D_arr_like_0p5, 0.5) def_gen.vonmises(0.5, D_arr_like_0p5) def_gen.vonmises(D_arr_0p5, D_arr_0p5) def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5) def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1) def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.wald(0.5, 0.5) def_gen.wald(0.5, 0.5, size=None) def_gen.wald(0.5, 0.5, size=1) def_gen.wald(D_arr_0p5, 0.5) def_gen.wald(0.5, D_arr_0p5) def_gen.wald(D_arr_0p5, 0.5, size=1) def_gen.wald(0.5, D_arr_0p5, size=1) def_gen.wald(D_arr_like_0p5, 0.5) def_gen.wald(0.5, D_arr_like_0p5) def_gen.wald(D_arr_0p5, D_arr_0p5) def_gen.wald(D_arr_like_0p5, D_arr_like_0p5) def_gen.wald(D_arr_0p5, D_arr_0p5, size=1) def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.uniform(0.5, 0.5) def_gen.uniform(0.5, 0.5, size=None) def_gen.uniform(0.5, 0.5, size=1) def_gen.uniform(D_arr_0p5, 0.5) def_gen.uniform(0.5, D_arr_0p5) def_gen.uniform(D_arr_0p5, 0.5, size=1) def_gen.uniform(0.5, D_arr_0p5, size=1) def_gen.uniform(D_arr_like_0p5, 0.5) def_gen.uniform(0.5, D_arr_like_0p5) def_gen.uniform(D_arr_0p5, D_arr_0p5) def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5) def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1) def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.beta(0.5, 0.5) def_gen.beta(0.5, 0.5, size=None) def_gen.beta(0.5, 0.5, size=1) def_gen.beta(D_arr_0p5, 0.5) def_gen.beta(0.5, D_arr_0p5) def_gen.beta(D_arr_0p5, 0.5, size=1) def_gen.beta(0.5, D_arr_0p5, size=1) def_gen.beta(D_arr_like_0p5, 0.5) def_gen.beta(0.5, D_arr_like_0p5) def_gen.beta(D_arr_0p5, D_arr_0p5) def_gen.beta(D_arr_like_0p5, D_arr_like_0p5) def_gen.beta(D_arr_0p5, D_arr_0p5, size=1) def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.f(0.5, 0.5) def_gen.f(0.5, 0.5, size=None) def_gen.f(0.5, 0.5, size=1) def_gen.f(D_arr_0p5, 0.5) def_gen.f(0.5, D_arr_0p5) def_gen.f(D_arr_0p5, 0.5, size=1) def_gen.f(0.5, D_arr_0p5, size=1) def_gen.f(D_arr_like_0p5, 0.5) def_gen.f(0.5, D_arr_like_0p5) def_gen.f(D_arr_0p5, D_arr_0p5) def_gen.f(D_arr_like_0p5, D_arr_like_0p5) def_gen.f(D_arr_0p5, D_arr_0p5, size=1) def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.gamma(0.5, 0.5) def_gen.gamma(0.5, 0.5, size=None) def_gen.gamma(0.5, 0.5, size=1) def_gen.gamma(D_arr_0p5, 0.5) def_gen.gamma(0.5, D_arr_0p5) def_gen.gamma(D_arr_0p5, 0.5, size=1) def_gen.gamma(0.5, D_arr_0p5, size=1) def_gen.gamma(D_arr_like_0p5, 0.5) def_gen.gamma(0.5, D_arr_like_0p5) def_gen.gamma(D_arr_0p5, D_arr_0p5) def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5) def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1) def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.gumbel(0.5, 0.5) def_gen.gumbel(0.5, 0.5, size=None) def_gen.gumbel(0.5, 0.5, size=1) def_gen.gumbel(D_arr_0p5, 0.5) def_gen.gumbel(0.5, D_arr_0p5) def_gen.gumbel(D_arr_0p5, 0.5, size=1) def_gen.gumbel(0.5, D_arr_0p5, size=1) def_gen.gumbel(D_arr_like_0p5, 0.5) def_gen.gumbel(0.5, D_arr_like_0p5) def_gen.gumbel(D_arr_0p5, D_arr_0p5) def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5) def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1) def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.laplace(0.5, 0.5) def_gen.laplace(0.5, 0.5, size=None) def_gen.laplace(0.5, 0.5, size=1) def_gen.laplace(D_arr_0p5, 0.5) def_gen.laplace(0.5, D_arr_0p5) def_gen.laplace(D_arr_0p5, 0.5, size=1) def_gen.laplace(0.5, D_arr_0p5, size=1) def_gen.laplace(D_arr_like_0p5, 0.5) def_gen.laplace(0.5, D_arr_like_0p5) def_gen.laplace(D_arr_0p5, D_arr_0p5) def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5) def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1) def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.logistic(0.5, 0.5) def_gen.logistic(0.5, 0.5, size=None) def_gen.logistic(0.5, 0.5, size=1) def_gen.logistic(D_arr_0p5, 0.5) def_gen.logistic(0.5, D_arr_0p5) def_gen.logistic(D_arr_0p5, 0.5, size=1) def_gen.logistic(0.5, D_arr_0p5, size=1) def_gen.logistic(D_arr_like_0p5, 0.5) def_gen.logistic(0.5, D_arr_like_0p5) def_gen.logistic(D_arr_0p5, D_arr_0p5) def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5) def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1) def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.lognormal(0.5, 0.5) def_gen.lognormal(0.5, 0.5, size=None) def_gen.lognormal(0.5, 0.5, size=1) def_gen.lognormal(D_arr_0p5, 0.5) def_gen.lognormal(0.5, D_arr_0p5) def_gen.lognormal(D_arr_0p5, 0.5, size=1) def_gen.lognormal(0.5, D_arr_0p5, size=1) def_gen.lognormal(D_arr_like_0p5, 0.5) def_gen.lognormal(0.5, D_arr_like_0p5) def_gen.lognormal(D_arr_0p5, D_arr_0p5) def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5) def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1) def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.noncentral_chisquare(0.5, 0.5) def_gen.noncentral_chisquare(0.5, 0.5, size=None) def_gen.noncentral_chisquare(0.5, 0.5, size=1) def_gen.noncentral_chisquare(D_arr_0p5, 0.5) def_gen.noncentral_chisquare(0.5, D_arr_0p5) def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1) def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1) def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5) def_gen.noncentral_chisquare(0.5, D_arr_like_0p5) def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5) def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5) def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1) def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.normal(0.5, 0.5) def_gen.normal(0.5, 0.5, size=None) def_gen.normal(0.5, 0.5, size=1) def_gen.normal(D_arr_0p5, 0.5) def_gen.normal(0.5, D_arr_0p5) def_gen.normal(D_arr_0p5, 0.5, size=1) def_gen.normal(0.5, D_arr_0p5, size=1) def_gen.normal(D_arr_like_0p5, 0.5) def_gen.normal(0.5, D_arr_like_0p5) def_gen.normal(D_arr_0p5, D_arr_0p5) def_gen.normal(D_arr_like_0p5, D_arr_like_0p5) def_gen.normal(D_arr_0p5, D_arr_0p5, size=1) def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1) def_gen.triangular(0.1, 0.5, 0.9) def_gen.triangular(0.1, 0.5, 0.9, size=None) def_gen.triangular(0.1, 0.5, 0.9, size=1) def_gen.triangular(D_arr_0p1, 0.5, 0.9) def_gen.triangular(0.1, D_arr_0p5, 0.9) def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1) def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1) def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9) def_gen.triangular(0.5, D_arr_like_0p5, 0.9) def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9) def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9) def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1) def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1) def_gen.noncentral_f(0.1, 0.5, 0.9) def_gen.noncentral_f(0.1, 0.5, 0.9, size=None) def_gen.noncentral_f(0.1, 0.5, 0.9, size=1) def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9) def_gen.noncentral_f(0.1, D_arr_0p5, 0.9) def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1) def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1) def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9) def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9) def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9) def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9) def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1) def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1) def_gen.binomial(10, 0.5) def_gen.binomial(10, 0.5, size=None) def_gen.binomial(10, 0.5, size=1) def_gen.binomial(I_arr_10, 0.5) def_gen.binomial(10, D_arr_0p5) def_gen.binomial(I_arr_10, 0.5, size=1) def_gen.binomial(10, D_arr_0p5, size=1) def_gen.binomial(I_arr_like_10, 0.5) def_gen.binomial(10, D_arr_like_0p5) def_gen.binomial(I_arr_10, D_arr_0p5) def_gen.binomial(I_arr_like_10, D_arr_like_0p5) def_gen.binomial(I_arr_10, D_arr_0p5, size=1) def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1) def_gen.negative_binomial(10, 0.5) def_gen.negative_binomial(10, 0.5, size=None) def_gen.negative_binomial(10, 0.5, size=1) def_gen.negative_binomial(I_arr_10, 0.5) def_gen.negative_binomial(10, D_arr_0p5) def_gen.negative_binomial(I_arr_10, 0.5, size=1) def_gen.negative_binomial(10, D_arr_0p5, size=1) def_gen.negative_binomial(I_arr_like_10, 0.5) def_gen.negative_binomial(10, D_arr_like_0p5) def_gen.negative_binomial(I_arr_10, D_arr_0p5) def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5) def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1) def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1) def_gen.hypergeometric(20, 20, 10) def_gen.hypergeometric(20, 20, 10, size=None) def_gen.hypergeometric(20, 20, 10, size=1) def_gen.hypergeometric(I_arr_20, 20, 10) def_gen.hypergeometric(20, I_arr_20, 10) def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1) def_gen.hypergeometric(20, I_arr_20, 10, size=1) def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10) def_gen.hypergeometric(20, I_arr_like_20, 10) def_gen.hypergeometric(I_arr_20, I_arr_20, 10) def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10) def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1) def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1) I_int64_100: np.ndarray[Any, np.dtype[np.int64]] = np.array([100], dtype=np.int64) def_gen.integers(0, 100) def_gen.integers(100) def_gen.integers([100]) def_gen.integers(0, [100]) I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_) I_bool_low_like: list[int] = [0] I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_) I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_) def_gen.integers(2, dtype=bool) def_gen.integers(0, 2, dtype=bool) def_gen.integers(1, dtype=bool, endpoint=True) def_gen.integers(0, 1, dtype=bool, endpoint=True) def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True) def_gen.integers(I_bool_high_open, dtype=bool) def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool) def_gen.integers(0, I_bool_high_open, dtype=bool) def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True) def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True) def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True) def_gen.integers(2, dtype=np.bool_) def_gen.integers(0, 2, dtype=np.bool_) def_gen.integers(1, dtype=np.bool_, endpoint=True) def_gen.integers(0, 1, dtype=np.bool_, endpoint=True) def_gen.integers(I_bool_low_like, 1, dtype=np.bool_, endpoint=True) def_gen.integers(I_bool_high_open, dtype=np.bool_) def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool_) def_gen.integers(0, I_bool_high_open, dtype=np.bool_) def_gen.integers(I_bool_high_closed, dtype=np.bool_, endpoint=True) def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool_, endpoint=True) def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True) I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8) I_u1_low_like: list[int] = [0] I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8) I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8) def_gen.integers(256, dtype="u1") def_gen.integers(0, 256, dtype="u1") def_gen.integers(255, dtype="u1", endpoint=True) def_gen.integers(0, 255, dtype="u1", endpoint=True) def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True) def_gen.integers(I_u1_high_open, dtype="u1") def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1") def_gen.integers(0, I_u1_high_open, dtype="u1") def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True) def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True) def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True) def_gen.integers(256, dtype="uint8") def_gen.integers(0, 256, dtype="uint8") def_gen.integers(255, dtype="uint8", endpoint=True) def_gen.integers(0, 255, dtype="uint8", endpoint=True) def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True) def_gen.integers(I_u1_high_open, dtype="uint8") def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8") def_gen.integers(0, I_u1_high_open, dtype="uint8") def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True) def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True) def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True) def_gen.integers(256, dtype=np.uint8) def_gen.integers(0, 256, dtype=np.uint8) def_gen.integers(255, dtype=np.uint8, endpoint=True) def_gen.integers(0, 255, dtype=np.uint8, endpoint=True) def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True) def_gen.integers(I_u1_high_open, dtype=np.uint8) def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8) def_gen.integers(0, I_u1_high_open, dtype=np.uint8) def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True) def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True) def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True) I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16) I_u2_low_like: list[int] = [0] I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16) I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16) def_gen.integers(65536, dtype="u2") def_gen.integers(0, 65536, dtype="u2") def_gen.integers(65535, dtype="u2", endpoint=True) def_gen.integers(0, 65535, dtype="u2", endpoint=True) def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True) def_gen.integers(I_u2_high_open, dtype="u2") def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2") def_gen.integers(0, I_u2_high_open, dtype="u2") def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True) def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True) def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True) def_gen.integers(65536, dtype="uint16") def_gen.integers(0, 65536, dtype="uint16") def_gen.integers(65535, dtype="uint16", endpoint=True) def_gen.integers(0, 65535, dtype="uint16", endpoint=True) def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True) def_gen.integers(I_u2_high_open, dtype="uint16") def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16") def_gen.integers(0, I_u2_high_open, dtype="uint16") def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True) def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True) def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True) def_gen.integers(65536, dtype=np.uint16) def_gen.integers(0, 65536, dtype=np.uint16) def_gen.integers(65535, dtype=np.uint16, endpoint=True) def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True) def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True) def_gen.integers(I_u2_high_open, dtype=np.uint16) def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16) def_gen.integers(0, I_u2_high_open, dtype=np.uint16) def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True) def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True) def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True) I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32) I_u4_low_like: list[int] = [0] I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32) I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32) def_gen.integers(4294967296, dtype="u4") def_gen.integers(0, 4294967296, dtype="u4") def_gen.integers(4294967295, dtype="u4", endpoint=True) def_gen.integers(0, 4294967295, dtype="u4", endpoint=True) def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True) def_gen.integers(I_u4_high_open, dtype="u4") def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4") def_gen.integers(0, I_u4_high_open, dtype="u4") def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True) def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True) def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True) def_gen.integers(4294967296, dtype="uint32") def_gen.integers(0, 4294967296, dtype="uint32") def_gen.integers(4294967295, dtype="uint32", endpoint=True) def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True) def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True) def_gen.integers(I_u4_high_open, dtype="uint32") def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32") def_gen.integers(0, I_u4_high_open, dtype="uint32") def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True) def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True) def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True) def_gen.integers(4294967296, dtype=np.uint32) def_gen.integers(0, 4294967296, dtype=np.uint32) def_gen.integers(4294967295, dtype=np.uint32, endpoint=True) def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True) def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True) def_gen.integers(I_u4_high_open, dtype=np.uint32) def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32) def_gen.integers(0, I_u4_high_open, dtype=np.uint32) def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True) def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True) def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True) I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64) I_u8_low_like: list[int] = [0] I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64) I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64) def_gen.integers(18446744073709551616, dtype="u8") def_gen.integers(0, 18446744073709551616, dtype="u8") def_gen.integers(18446744073709551615, dtype="u8", endpoint=True) def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True) def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True) def_gen.integers(I_u8_high_open, dtype="u8") def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8") def_gen.integers(0, I_u8_high_open, dtype="u8") def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True) def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True) def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True) def_gen.integers(18446744073709551616, dtype="uint64") def_gen.integers(0, 18446744073709551616, dtype="uint64") def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True) def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True) def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True) def_gen.integers(I_u8_high_open, dtype="uint64") def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64") def_gen.integers(0, I_u8_high_open, dtype="uint64") def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True) def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True) def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True) def_gen.integers(18446744073709551616, dtype=np.uint64) def_gen.integers(0, 18446744073709551616, dtype=np.uint64) def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True) def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True) def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True) def_gen.integers(I_u8_high_open, dtype=np.uint64) def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64) def_gen.integers(0, I_u8_high_open, dtype=np.uint64) def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True) def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True) def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True) I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8) I_i1_low_like: list[int] = [-128] I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8) I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8) def_gen.integers(128, dtype="i1") def_gen.integers(-128, 128, dtype="i1") def_gen.integers(127, dtype="i1", endpoint=True) def_gen.integers(-128, 127, dtype="i1", endpoint=True) def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True) def_gen.integers(I_i1_high_open, dtype="i1") def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1") def_gen.integers(-128, I_i1_high_open, dtype="i1") def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True) def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True) def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True) def_gen.integers(128, dtype="int8") def_gen.integers(-128, 128, dtype="int8") def_gen.integers(127, dtype="int8", endpoint=True) def_gen.integers(-128, 127, dtype="int8", endpoint=True) def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True) def_gen.integers(I_i1_high_open, dtype="int8") def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8") def_gen.integers(-128, I_i1_high_open, dtype="int8") def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True) def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True) def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True) def_gen.integers(128, dtype=np.int8) def_gen.integers(-128, 128, dtype=np.int8) def_gen.integers(127, dtype=np.int8, endpoint=True) def_gen.integers(-128, 127, dtype=np.int8, endpoint=True) def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True) def_gen.integers(I_i1_high_open, dtype=np.int8) def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8) def_gen.integers(-128, I_i1_high_open, dtype=np.int8) def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True) def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True) def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True) I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16) I_i2_low_like: list[int] = [-32768] I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16) I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16) def_gen.integers(32768, dtype="i2") def_gen.integers(-32768, 32768, dtype="i2") def_gen.integers(32767, dtype="i2", endpoint=True) def_gen.integers(-32768, 32767, dtype="i2", endpoint=True) def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True) def_gen.integers(I_i2_high_open, dtype="i2") def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2") def_gen.integers(-32768, I_i2_high_open, dtype="i2") def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True) def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True) def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True) def_gen.integers(32768, dtype="int16") def_gen.integers(-32768, 32768, dtype="int16") def_gen.integers(32767, dtype="int16", endpoint=True) def_gen.integers(-32768, 32767, dtype="int16", endpoint=True) def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True) def_gen.integers(I_i2_high_open, dtype="int16") def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16") def_gen.integers(-32768, I_i2_high_open, dtype="int16") def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True) def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True) def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True) def_gen.integers(32768, dtype=np.int16) def_gen.integers(-32768, 32768, dtype=np.int16) def_gen.integers(32767, dtype=np.int16, endpoint=True) def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True) def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True) def_gen.integers(I_i2_high_open, dtype=np.int16) def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16) def_gen.integers(-32768, I_i2_high_open, dtype=np.int16) def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True) def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True) def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True) I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32) I_i4_low_like: list[int] = [-2147483648] I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32) I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32) def_gen.integers(2147483648, dtype="i4") def_gen.integers(-2147483648, 2147483648, dtype="i4") def_gen.integers(2147483647, dtype="i4", endpoint=True) def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True) def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True) def_gen.integers(I_i4_high_open, dtype="i4") def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4") def_gen.integers(-2147483648, I_i4_high_open, dtype="i4") def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True) def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True) def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True) def_gen.integers(2147483648, dtype="int32") def_gen.integers(-2147483648, 2147483648, dtype="int32") def_gen.integers(2147483647, dtype="int32", endpoint=True) def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True) def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True) def_gen.integers(I_i4_high_open, dtype="int32") def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32") def_gen.integers(-2147483648, I_i4_high_open, dtype="int32") def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True) def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True) def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True) def_gen.integers(2147483648, dtype=np.int32) def_gen.integers(-2147483648, 2147483648, dtype=np.int32) def_gen.integers(2147483647, dtype=np.int32, endpoint=True) def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True) def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True) def_gen.integers(I_i4_high_open, dtype=np.int32) def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32) def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32) def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True) def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True) def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True) I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64) I_i8_low_like: list[int] = [-9223372036854775808] I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64) I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64) def_gen.integers(9223372036854775808, dtype="i8") def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8") def_gen.integers(9223372036854775807, dtype="i8", endpoint=True) def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True) def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True) def_gen.integers(I_i8_high_open, dtype="i8") def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8") def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8") def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True) def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True) def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True) def_gen.integers(9223372036854775808, dtype="int64") def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64") def_gen.integers(9223372036854775807, dtype="int64", endpoint=True) def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True) def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True) def_gen.integers(I_i8_high_open, dtype="int64") def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64") def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64") def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True) def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True) def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True) def_gen.integers(9223372036854775808, dtype=np.int64) def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64) def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True) def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True) def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True) def_gen.integers(I_i8_high_open, dtype=np.int64) def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64) def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64) def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True) def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True) def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True) def_gen.bit_generator def_gen.bytes(2) def_gen.choice(5) def_gen.choice(5, 3) def_gen.choice(5, 3, replace=True) def_gen.choice(5, 3, p=[1 / 5] * 5) def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False) def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"]) def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3) def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4) def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True) def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])) def_gen.dirichlet([0.5, 0.5]) def_gen.dirichlet(np.array([0.5, 0.5])) def_gen.dirichlet(np.array([0.5, 0.5]), size=3) def_gen.multinomial(20, [1 / 6.0] * 6) def_gen.multinomial(20, np.array([0.5, 0.5])) def_gen.multinomial(20, [1 / 6.0] * 6, size=2) def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2)) def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2)) def_gen.multivariate_hypergeometric([3, 5, 7], 2) def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2) def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4) def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7)) def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count") def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals") def_gen.multivariate_normal([0.0], [[1.0]]) def_gen.multivariate_normal([0.0], np.array([[1.0]])) def_gen.multivariate_normal(np.array([0.0]), [[1.0]]) def_gen.multivariate_normal([0.0], np.array([[1.0]])) def_gen.permutation(10) def_gen.permutation([1, 2, 3, 4]) def_gen.permutation(np.array([1, 2, 3, 4])) def_gen.permutation(D_2D, axis=1) def_gen.permuted(D_2D) def_gen.permuted(D_2D_like) def_gen.permuted(D_2D, axis=1) def_gen.permuted(D_2D, out=D_2D) def_gen.permuted(D_2D_like, out=D_2D) def_gen.permuted(D_2D_like, out=D_2D) def_gen.permuted(D_2D, axis=1, out=D_2D) def_gen.shuffle(np.arange(10)) def_gen.shuffle([1, 2, 3, 4, 5]) def_gen.shuffle(D_2D, axis=1) def_gen.__str__() def_gen.__repr__() def_gen_state: dict[str, Any] def_gen_state = def_gen.__getstate__() def_gen.__setstate__(def_gen_state) # RandomState random_st: np.random.RandomState = np.random.RandomState() random_st.standard_normal() random_st.standard_normal(size=None) random_st.standard_normal(size=1) random_st.random() random_st.random(size=None) random_st.random(size=1) random_st.standard_cauchy() random_st.standard_cauchy(size=None) random_st.standard_cauchy(size=1) random_st.standard_exponential() random_st.standard_exponential(size=None) random_st.standard_exponential(size=1) random_st.zipf(1.5) random_st.zipf(1.5, size=None) random_st.zipf(1.5, size=1) random_st.zipf(D_arr_1p5) random_st.zipf(D_arr_1p5, size=1) random_st.zipf(D_arr_like_1p5) random_st.zipf(D_arr_like_1p5, size=1) random_st.weibull(0.5) random_st.weibull(0.5, size=None) random_st.weibull(0.5, size=1) random_st.weibull(D_arr_0p5) random_st.weibull(D_arr_0p5, size=1) random_st.weibull(D_arr_like_0p5) random_st.weibull(D_arr_like_0p5, size=1) random_st.standard_t(0.5) random_st.standard_t(0.5, size=None) random_st.standard_t(0.5, size=1) random_st.standard_t(D_arr_0p5) random_st.standard_t(D_arr_0p5, size=1) random_st.standard_t(D_arr_like_0p5) random_st.standard_t(D_arr_like_0p5, size=1) random_st.poisson(0.5) random_st.poisson(0.5, size=None) random_st.poisson(0.5, size=1) random_st.poisson(D_arr_0p5) random_st.poisson(D_arr_0p5, size=1) random_st.poisson(D_arr_like_0p5) random_st.poisson(D_arr_like_0p5, size=1) random_st.power(0.5) random_st.power(0.5, size=None) random_st.power(0.5, size=1) random_st.power(D_arr_0p5) random_st.power(D_arr_0p5, size=1) random_st.power(D_arr_like_0p5) random_st.power(D_arr_like_0p5, size=1) random_st.pareto(0.5) random_st.pareto(0.5, size=None) random_st.pareto(0.5, size=1) random_st.pareto(D_arr_0p5) random_st.pareto(D_arr_0p5, size=1) random_st.pareto(D_arr_like_0p5) random_st.pareto(D_arr_like_0p5, size=1) random_st.chisquare(0.5) random_st.chisquare(0.5, size=None) random_st.chisquare(0.5, size=1) random_st.chisquare(D_arr_0p5) random_st.chisquare(D_arr_0p5, size=1) random_st.chisquare(D_arr_like_0p5) random_st.chisquare(D_arr_like_0p5, size=1) random_st.exponential(0.5) random_st.exponential(0.5, size=None) random_st.exponential(0.5, size=1) random_st.exponential(D_arr_0p5) random_st.exponential(D_arr_0p5, size=1) random_st.exponential(D_arr_like_0p5) random_st.exponential(D_arr_like_0p5, size=1) random_st.geometric(0.5) random_st.geometric(0.5, size=None) random_st.geometric(0.5, size=1) random_st.geometric(D_arr_0p5) random_st.geometric(D_arr_0p5, size=1) random_st.geometric(D_arr_like_0p5) random_st.geometric(D_arr_like_0p5, size=1) random_st.logseries(0.5) random_st.logseries(0.5, size=None) random_st.logseries(0.5, size=1) random_st.logseries(D_arr_0p5) random_st.logseries(D_arr_0p5, size=1) random_st.logseries(D_arr_like_0p5) random_st.logseries(D_arr_like_0p5, size=1) random_st.rayleigh(0.5) random_st.rayleigh(0.5, size=None) random_st.rayleigh(0.5, size=1) random_st.rayleigh(D_arr_0p5) random_st.rayleigh(D_arr_0p5, size=1) random_st.rayleigh(D_arr_like_0p5) random_st.rayleigh(D_arr_like_0p5, size=1) random_st.standard_gamma(0.5) random_st.standard_gamma(0.5, size=None) random_st.standard_gamma(0.5, size=1) random_st.standard_gamma(D_arr_0p5) random_st.standard_gamma(D_arr_0p5, size=1) random_st.standard_gamma(D_arr_like_0p5) random_st.standard_gamma(D_arr_like_0p5, size=1) random_st.standard_gamma(D_arr_like_0p5, size=1) random_st.vonmises(0.5, 0.5) random_st.vonmises(0.5, 0.5, size=None) random_st.vonmises(0.5, 0.5, size=1) random_st.vonmises(D_arr_0p5, 0.5) random_st.vonmises(0.5, D_arr_0p5) random_st.vonmises(D_arr_0p5, 0.5, size=1) random_st.vonmises(0.5, D_arr_0p5, size=1) random_st.vonmises(D_arr_like_0p5, 0.5) random_st.vonmises(0.5, D_arr_like_0p5) random_st.vonmises(D_arr_0p5, D_arr_0p5) random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5) random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1) random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.wald(0.5, 0.5) random_st.wald(0.5, 0.5, size=None) random_st.wald(0.5, 0.5, size=1) random_st.wald(D_arr_0p5, 0.5) random_st.wald(0.5, D_arr_0p5) random_st.wald(D_arr_0p5, 0.5, size=1) random_st.wald(0.5, D_arr_0p5, size=1) random_st.wald(D_arr_like_0p5, 0.5) random_st.wald(0.5, D_arr_like_0p5) random_st.wald(D_arr_0p5, D_arr_0p5) random_st.wald(D_arr_like_0p5, D_arr_like_0p5) random_st.wald(D_arr_0p5, D_arr_0p5, size=1) random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.uniform(0.5, 0.5) random_st.uniform(0.5, 0.5, size=None) random_st.uniform(0.5, 0.5, size=1) random_st.uniform(D_arr_0p5, 0.5) random_st.uniform(0.5, D_arr_0p5) random_st.uniform(D_arr_0p5, 0.5, size=1) random_st.uniform(0.5, D_arr_0p5, size=1) random_st.uniform(D_arr_like_0p5, 0.5) random_st.uniform(0.5, D_arr_like_0p5) random_st.uniform(D_arr_0p5, D_arr_0p5) random_st.uniform(D_arr_like_0p5, D_arr_like_0p5) random_st.uniform(D_arr_0p5, D_arr_0p5, size=1) random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.beta(0.5, 0.5) random_st.beta(0.5, 0.5, size=None) random_st.beta(0.5, 0.5, size=1) random_st.beta(D_arr_0p5, 0.5) random_st.beta(0.5, D_arr_0p5) random_st.beta(D_arr_0p5, 0.5, size=1) random_st.beta(0.5, D_arr_0p5, size=1) random_st.beta(D_arr_like_0p5, 0.5) random_st.beta(0.5, D_arr_like_0p5) random_st.beta(D_arr_0p5, D_arr_0p5) random_st.beta(D_arr_like_0p5, D_arr_like_0p5) random_st.beta(D_arr_0p5, D_arr_0p5, size=1) random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.f(0.5, 0.5) random_st.f(0.5, 0.5, size=None) random_st.f(0.5, 0.5, size=1) random_st.f(D_arr_0p5, 0.5) random_st.f(0.5, D_arr_0p5) random_st.f(D_arr_0p5, 0.5, size=1) random_st.f(0.5, D_arr_0p5, size=1) random_st.f(D_arr_like_0p5, 0.5) random_st.f(0.5, D_arr_like_0p5) random_st.f(D_arr_0p5, D_arr_0p5) random_st.f(D_arr_like_0p5, D_arr_like_0p5) random_st.f(D_arr_0p5, D_arr_0p5, size=1) random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.gamma(0.5, 0.5) random_st.gamma(0.5, 0.5, size=None) random_st.gamma(0.5, 0.5, size=1) random_st.gamma(D_arr_0p5, 0.5) random_st.gamma(0.5, D_arr_0p5) random_st.gamma(D_arr_0p5, 0.5, size=1) random_st.gamma(0.5, D_arr_0p5, size=1) random_st.gamma(D_arr_like_0p5, 0.5) random_st.gamma(0.5, D_arr_like_0p5) random_st.gamma(D_arr_0p5, D_arr_0p5) random_st.gamma(D_arr_like_0p5, D_arr_like_0p5) random_st.gamma(D_arr_0p5, D_arr_0p5, size=1) random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.gumbel(0.5, 0.5) random_st.gumbel(0.5, 0.5, size=None) random_st.gumbel(0.5, 0.5, size=1) random_st.gumbel(D_arr_0p5, 0.5) random_st.gumbel(0.5, D_arr_0p5) random_st.gumbel(D_arr_0p5, 0.5, size=1) random_st.gumbel(0.5, D_arr_0p5, size=1) random_st.gumbel(D_arr_like_0p5, 0.5) random_st.gumbel(0.5, D_arr_like_0p5) random_st.gumbel(D_arr_0p5, D_arr_0p5) random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5) random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1) random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.laplace(0.5, 0.5) random_st.laplace(0.5, 0.5, size=None) random_st.laplace(0.5, 0.5, size=1) random_st.laplace(D_arr_0p5, 0.5) random_st.laplace(0.5, D_arr_0p5) random_st.laplace(D_arr_0p5, 0.5, size=1) random_st.laplace(0.5, D_arr_0p5, size=1) random_st.laplace(D_arr_like_0p5, 0.5) random_st.laplace(0.5, D_arr_like_0p5) random_st.laplace(D_arr_0p5, D_arr_0p5) random_st.laplace(D_arr_like_0p5, D_arr_like_0p5) random_st.laplace(D_arr_0p5, D_arr_0p5, size=1) random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.logistic(0.5, 0.5) random_st.logistic(0.5, 0.5, size=None) random_st.logistic(0.5, 0.5, size=1) random_st.logistic(D_arr_0p5, 0.5) random_st.logistic(0.5, D_arr_0p5) random_st.logistic(D_arr_0p5, 0.5, size=1) random_st.logistic(0.5, D_arr_0p5, size=1) random_st.logistic(D_arr_like_0p5, 0.5) random_st.logistic(0.5, D_arr_like_0p5) random_st.logistic(D_arr_0p5, D_arr_0p5) random_st.logistic(D_arr_like_0p5, D_arr_like_0p5) random_st.logistic(D_arr_0p5, D_arr_0p5, size=1) random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.lognormal(0.5, 0.5) random_st.lognormal(0.5, 0.5, size=None) random_st.lognormal(0.5, 0.5, size=1) random_st.lognormal(D_arr_0p5, 0.5) random_st.lognormal(0.5, D_arr_0p5) random_st.lognormal(D_arr_0p5, 0.5, size=1) random_st.lognormal(0.5, D_arr_0p5, size=1) random_st.lognormal(D_arr_like_0p5, 0.5) random_st.lognormal(0.5, D_arr_like_0p5) random_st.lognormal(D_arr_0p5, D_arr_0p5) random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5) random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1) random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.noncentral_chisquare(0.5, 0.5) random_st.noncentral_chisquare(0.5, 0.5, size=None) random_st.noncentral_chisquare(0.5, 0.5, size=1) random_st.noncentral_chisquare(D_arr_0p5, 0.5) random_st.noncentral_chisquare(0.5, D_arr_0p5) random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1) random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1) random_st.noncentral_chisquare(D_arr_like_0p5, 0.5) random_st.noncentral_chisquare(0.5, D_arr_like_0p5) random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5) random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5) random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1) random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.normal(0.5, 0.5) random_st.normal(0.5, 0.5, size=None) random_st.normal(0.5, 0.5, size=1) random_st.normal(D_arr_0p5, 0.5) random_st.normal(0.5, D_arr_0p5) random_st.normal(D_arr_0p5, 0.5, size=1) random_st.normal(0.5, D_arr_0p5, size=1) random_st.normal(D_arr_like_0p5, 0.5) random_st.normal(0.5, D_arr_like_0p5) random_st.normal(D_arr_0p5, D_arr_0p5) random_st.normal(D_arr_like_0p5, D_arr_like_0p5) random_st.normal(D_arr_0p5, D_arr_0p5, size=1) random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1) random_st.triangular(0.1, 0.5, 0.9) random_st.triangular(0.1, 0.5, 0.9, size=None) random_st.triangular(0.1, 0.5, 0.9, size=1) random_st.triangular(D_arr_0p1, 0.5, 0.9) random_st.triangular(0.1, D_arr_0p5, 0.9) random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1) random_st.triangular(0.1, D_arr_0p5, 0.9, size=1) random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9) random_st.triangular(0.5, D_arr_like_0p5, 0.9) random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9) random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9) random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1) random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1) random_st.noncentral_f(0.1, 0.5, 0.9) random_st.noncentral_f(0.1, 0.5, 0.9, size=None) random_st.noncentral_f(0.1, 0.5, 0.9, size=1) random_st.noncentral_f(D_arr_0p1, 0.5, 0.9) random_st.noncentral_f(0.1, D_arr_0p5, 0.9) random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1) random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1) random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9) random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9) random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9) random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9) random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1) random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1) random_st.binomial(10, 0.5) random_st.binomial(10, 0.5, size=None) random_st.binomial(10, 0.5, size=1) random_st.binomial(I_arr_10, 0.5) random_st.binomial(10, D_arr_0p5) random_st.binomial(I_arr_10, 0.5, size=1) random_st.binomial(10, D_arr_0p5, size=1) random_st.binomial(I_arr_like_10, 0.5) random_st.binomial(10, D_arr_like_0p5) random_st.binomial(I_arr_10, D_arr_0p5) random_st.binomial(I_arr_like_10, D_arr_like_0p5) random_st.binomial(I_arr_10, D_arr_0p5, size=1) random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1) random_st.negative_binomial(10, 0.5) random_st.negative_binomial(10, 0.5, size=None) random_st.negative_binomial(10, 0.5, size=1) random_st.negative_binomial(I_arr_10, 0.5) random_st.negative_binomial(10, D_arr_0p5) random_st.negative_binomial(I_arr_10, 0.5, size=1) random_st.negative_binomial(10, D_arr_0p5, size=1) random_st.negative_binomial(I_arr_like_10, 0.5) random_st.negative_binomial(10, D_arr_like_0p5) random_st.negative_binomial(I_arr_10, D_arr_0p5) random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5) random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1) random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1) random_st.hypergeometric(20, 20, 10) random_st.hypergeometric(20, 20, 10, size=None) random_st.hypergeometric(20, 20, 10, size=1) random_st.hypergeometric(I_arr_20, 20, 10) random_st.hypergeometric(20, I_arr_20, 10) random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1) random_st.hypergeometric(20, I_arr_20, 10, size=1) random_st.hypergeometric(I_arr_like_20, 20, I_arr_10) random_st.hypergeometric(20, I_arr_like_20, 10) random_st.hypergeometric(I_arr_20, I_arr_20, 10) random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10) random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1) random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1) random_st.randint(0, 100) random_st.randint(100) random_st.randint([100]) random_st.randint(0, [100]) random_st.randint(2, dtype=bool) random_st.randint(0, 2, dtype=bool) random_st.randint(I_bool_high_open, dtype=bool) random_st.randint(I_bool_low, I_bool_high_open, dtype=bool) random_st.randint(0, I_bool_high_open, dtype=bool) random_st.randint(2, dtype=np.bool_) random_st.randint(0, 2, dtype=np.bool_) random_st.randint(I_bool_high_open, dtype=np.bool_) random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool_) random_st.randint(0, I_bool_high_open, dtype=np.bool_) random_st.randint(256, dtype="u1") random_st.randint(0, 256, dtype="u1") random_st.randint(I_u1_high_open, dtype="u1") random_st.randint(I_u1_low, I_u1_high_open, dtype="u1") random_st.randint(0, I_u1_high_open, dtype="u1") random_st.randint(256, dtype="uint8") random_st.randint(0, 256, dtype="uint8") random_st.randint(I_u1_high_open, dtype="uint8") random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8") random_st.randint(0, I_u1_high_open, dtype="uint8") random_st.randint(256, dtype=np.uint8) random_st.randint(0, 256, dtype=np.uint8) random_st.randint(I_u1_high_open, dtype=np.uint8) random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8) random_st.randint(0, I_u1_high_open, dtype=np.uint8) random_st.randint(65536, dtype="u2") random_st.randint(0, 65536, dtype="u2") random_st.randint(I_u2_high_open, dtype="u2") random_st.randint(I_u2_low, I_u2_high_open, dtype="u2") random_st.randint(0, I_u2_high_open, dtype="u2") random_st.randint(65536, dtype="uint16") random_st.randint(0, 65536, dtype="uint16") random_st.randint(I_u2_high_open, dtype="uint16") random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16") random_st.randint(0, I_u2_high_open, dtype="uint16") random_st.randint(65536, dtype=np.uint16) random_st.randint(0, 65536, dtype=np.uint16) random_st.randint(I_u2_high_open, dtype=np.uint16) random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16) random_st.randint(0, I_u2_high_open, dtype=np.uint16) random_st.randint(4294967296, dtype="u4") random_st.randint(0, 4294967296, dtype="u4") random_st.randint(I_u4_high_open, dtype="u4") random_st.randint(I_u4_low, I_u4_high_open, dtype="u4") random_st.randint(0, I_u4_high_open, dtype="u4") random_st.randint(4294967296, dtype="uint32") random_st.randint(0, 4294967296, dtype="uint32") random_st.randint(I_u4_high_open, dtype="uint32") random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32") random_st.randint(0, I_u4_high_open, dtype="uint32") random_st.randint(4294967296, dtype=np.uint32) random_st.randint(0, 4294967296, dtype=np.uint32) random_st.randint(I_u4_high_open, dtype=np.uint32) random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32) random_st.randint(0, I_u4_high_open, dtype=np.uint32) random_st.randint(18446744073709551616, dtype="u8") random_st.randint(0, 18446744073709551616, dtype="u8") random_st.randint(I_u8_high_open, dtype="u8") random_st.randint(I_u8_low, I_u8_high_open, dtype="u8") random_st.randint(0, I_u8_high_open, dtype="u8") random_st.randint(18446744073709551616, dtype="uint64") random_st.randint(0, 18446744073709551616, dtype="uint64") random_st.randint(I_u8_high_open, dtype="uint64") random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64") random_st.randint(0, I_u8_high_open, dtype="uint64") random_st.randint(18446744073709551616, dtype=np.uint64) random_st.randint(0, 18446744073709551616, dtype=np.uint64) random_st.randint(I_u8_high_open, dtype=np.uint64) random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64) random_st.randint(0, I_u8_high_open, dtype=np.uint64) random_st.randint(128, dtype="i1") random_st.randint(-128, 128, dtype="i1") random_st.randint(I_i1_high_open, dtype="i1") random_st.randint(I_i1_low, I_i1_high_open, dtype="i1") random_st.randint(-128, I_i1_high_open, dtype="i1") random_st.randint(128, dtype="int8") random_st.randint(-128, 128, dtype="int8") random_st.randint(I_i1_high_open, dtype="int8") random_st.randint(I_i1_low, I_i1_high_open, dtype="int8") random_st.randint(-128, I_i1_high_open, dtype="int8") random_st.randint(128, dtype=np.int8) random_st.randint(-128, 128, dtype=np.int8) random_st.randint(I_i1_high_open, dtype=np.int8) random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8) random_st.randint(-128, I_i1_high_open, dtype=np.int8) random_st.randint(32768, dtype="i2") random_st.randint(-32768, 32768, dtype="i2") random_st.randint(I_i2_high_open, dtype="i2") random_st.randint(I_i2_low, I_i2_high_open, dtype="i2") random_st.randint(-32768, I_i2_high_open, dtype="i2") random_st.randint(32768, dtype="int16") random_st.randint(-32768, 32768, dtype="int16") random_st.randint(I_i2_high_open, dtype="int16") random_st.randint(I_i2_low, I_i2_high_open, dtype="int16") random_st.randint(-32768, I_i2_high_open, dtype="int16") random_st.randint(32768, dtype=np.int16) random_st.randint(-32768, 32768, dtype=np.int16) random_st.randint(I_i2_high_open, dtype=np.int16) random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16) random_st.randint(-32768, I_i2_high_open, dtype=np.int16) random_st.randint(2147483648, dtype="i4") random_st.randint(-2147483648, 2147483648, dtype="i4") random_st.randint(I_i4_high_open, dtype="i4") random_st.randint(I_i4_low, I_i4_high_open, dtype="i4") random_st.randint(-2147483648, I_i4_high_open, dtype="i4") random_st.randint(2147483648, dtype="int32") random_st.randint(-2147483648, 2147483648, dtype="int32") random_st.randint(I_i4_high_open, dtype="int32") random_st.randint(I_i4_low, I_i4_high_open, dtype="int32") random_st.randint(-2147483648, I_i4_high_open, dtype="int32") random_st.randint(2147483648, dtype=np.int32) random_st.randint(-2147483648, 2147483648, dtype=np.int32) random_st.randint(I_i4_high_open, dtype=np.int32) random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32) random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32) random_st.randint(9223372036854775808, dtype="i8") random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8") random_st.randint(I_i8_high_open, dtype="i8") random_st.randint(I_i8_low, I_i8_high_open, dtype="i8") random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8") random_st.randint(9223372036854775808, dtype="int64") random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64") random_st.randint(I_i8_high_open, dtype="int64") random_st.randint(I_i8_low, I_i8_high_open, dtype="int64") random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64") random_st.randint(9223372036854775808, dtype=np.int64) random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64) random_st.randint(I_i8_high_open, dtype=np.int64) random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64) random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64) bg: np.random.BitGenerator = random_st._bit_generator random_st.bytes(2) random_st.choice(5) random_st.choice(5, 3) random_st.choice(5, 3, replace=True) random_st.choice(5, 3, p=[1 / 5] * 5) random_st.choice(5, 3, p=[1 / 5] * 5, replace=False) random_st.choice(["pooh", "rabbit", "piglet", "Christopher"]) random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3) random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4) random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True) random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])) random_st.dirichlet([0.5, 0.5]) random_st.dirichlet(np.array([0.5, 0.5])) random_st.dirichlet(np.array([0.5, 0.5]), size=3) random_st.multinomial(20, [1 / 6.0] * 6) random_st.multinomial(20, np.array([0.5, 0.5])) random_st.multinomial(20, [1 / 6.0] * 6, size=2) random_st.multivariate_normal([0.0], [[1.0]]) random_st.multivariate_normal([0.0], np.array([[1.0]])) random_st.multivariate_normal(np.array([0.0]), [[1.0]]) random_st.multivariate_normal([0.0], np.array([[1.0]])) random_st.permutation(10) random_st.permutation([1, 2, 3, 4]) random_st.permutation(np.array([1, 2, 3, 4])) random_st.permutation(D_2D) random_st.shuffle(np.arange(10)) random_st.shuffle([1, 2, 3, 4, 5]) random_st.shuffle(D_2D) np.random.RandomState(SEED_PCG64) np.random.RandomState(0) np.random.RandomState([0, 1, 2]) random_st.__str__() random_st.__repr__() random_st_state = random_st.__getstate__() random_st.__setstate__(random_st_state) random_st.seed() random_st.seed(1) random_st.seed([0, 1]) random_st_get_state = random_st.get_state() random_st_get_state_legacy = random_st.get_state(legacy=True) random_st.set_state(random_st_get_state) random_st.rand() random_st.rand(1) random_st.rand(1, 2) random_st.randn() random_st.randn(1) random_st.randn(1, 2) random_st.random_sample() random_st.random_sample(1) random_st.random_sample(size=(1, 2)) random_st.tomaxint() random_st.tomaxint(1) random_st.tomaxint((1,)) np.random.set_bit_generator(SEED_PCG64) np.random.get_bit_generator() PKIZCo data/pass/scalars.pynu[import sys import datetime as dt import pytest import numpy as np b = np.bool_() u8 = np.uint64() i8 = np.int64() f8 = np.float64() c16 = np.complex128() U = np.str_() S = np.bytes_() # Construction class D: def __index__(self) -> int: return 0 class C: def __complex__(self) -> complex: return 3j class B: def __int__(self) -> int: return 4 class A: def __float__(self) -> float: return 4.0 np.complex64(3j) np.complex64(A()) np.complex64(C()) np.complex128(3j) np.complex128(C()) np.complex128(None) np.complex64("1.2") np.complex128(b"2j") np.int8(4) np.int16(3.4) np.int32(4) np.int64(-1) np.uint8(B()) np.uint32() np.int32("1") np.int64(b"2") np.float16(A()) np.float32(16) np.float64(3.0) np.float64(None) np.float32("1") np.float16(b"2.5") np.uint64(D()) np.float32(D()) np.complex64(D()) np.bytes_(b"hello") np.bytes_("hello", 'utf-8') np.bytes_("hello", encoding='utf-8') np.str_("hello") np.str_(b"hello", 'utf-8') np.str_(b"hello", encoding='utf-8') # Array-ish semantics np.int8().real np.int16().imag np.int32().data np.int64().flags np.uint8().itemsize * 2 np.uint16().ndim + 1 np.uint32().strides np.uint64().shape # Time structures np.datetime64() np.datetime64(0, "D") np.datetime64(0, b"D") np.datetime64(0, ('ms', 3)) np.datetime64("2019") np.datetime64(b"2019") np.datetime64("2019", "D") np.datetime64(np.datetime64()) np.datetime64(dt.datetime(2000, 5, 3)) np.datetime64(dt.date(2000, 5, 3)) np.datetime64(None) np.datetime64(None, "D") np.timedelta64() np.timedelta64(0) np.timedelta64(0, "D") np.timedelta64(0, ('ms', 3)) np.timedelta64(0, b"D") np.timedelta64("3") np.timedelta64(b"5") np.timedelta64(np.timedelta64(2)) np.timedelta64(dt.timedelta(2)) np.timedelta64(None) np.timedelta64(None, "D") np.void(1) np.void(np.int64(1)) np.void(True) np.void(np.bool_(True)) np.void(b"test") np.void(np.bytes_("test")) np.void(object(), [("a", "O"), ("b", "O")]) np.void(object(), dtype=[("a", "O"), ("b", "O")]) # Protocols i8 = np.int64() u8 = np.uint64() f8 = np.float64() c16 = np.complex128() b_ = np.bool_() td = np.timedelta64() U = np.str_("1") S = np.bytes_("1") AR = np.array(1, dtype=np.float64) int(i8) int(u8) int(f8) int(b_) int(td) int(U) int(S) int(AR) with pytest.warns(np.ComplexWarning): int(c16) float(i8) float(u8) float(f8) float(b_) float(td) float(U) float(S) float(AR) with pytest.warns(np.ComplexWarning): float(c16) complex(i8) complex(u8) complex(f8) complex(c16) complex(b_) complex(td) complex(U) complex(AR) # Misc c16.dtype c16.real c16.imag c16.real.real c16.real.imag c16.ndim c16.size c16.itemsize c16.shape c16.strides c16.squeeze() c16.byteswap() c16.transpose() # Aliases np.string_() np.byte() np.short() np.intc() np.intp() np.int_() np.longlong() np.ubyte() np.ushort() np.uintc() np.uintp() np.uint() np.ulonglong() np.half() np.single() np.double() np.float_() np.longdouble() np.longfloat() np.csingle() np.singlecomplex() np.cdouble() np.complex_() np.cfloat() np.clongdouble() np.clongfloat() np.longcomplex() b.item() i8.item() u8.item() f8.item() c16.item() U.item() S.item() b.tolist() i8.tolist() u8.tolist() f8.tolist() c16.tolist() U.tolist() S.tolist() b.ravel() i8.ravel() u8.ravel() f8.ravel() c16.ravel() U.ravel() S.ravel() b.flatten() i8.flatten() u8.flatten() f8.flatten() c16.flatten() U.flatten() S.flatten() b.reshape(1) i8.reshape(1) u8.reshape(1) f8.reshape(1) c16.reshape(1) U.reshape(1) S.reshape(1) PKIZ赫t t data/pass/simple.pynu["""Simple expression that should pass with mypy.""" import operator import numpy as np from collections.abc import Iterable # Basic checks array = np.array([1, 2]) def ndarray_func(x): # type: (np.ndarray) -> np.ndarray return x ndarray_func(np.array([1, 2])) array == 1 array.dtype == float # Dtype construction np.dtype(float) np.dtype(np.float64) np.dtype(None) np.dtype("float64") np.dtype(np.dtype(float)) np.dtype(("U", 10)) np.dtype((np.int32, (2, 2))) # Define the arguments on the previous line to prevent bidirectional # type inference in mypy from broadening the types. two_tuples_dtype = [("R", "u1"), ("G", "u1"), ("B", "u1")] np.dtype(two_tuples_dtype) three_tuples_dtype = [("R", "u1", 2)] np.dtype(three_tuples_dtype) mixed_tuples_dtype = [("R", "u1"), ("G", np.str_, 1)] np.dtype(mixed_tuples_dtype) shape_tuple_dtype = [("R", "u1", (2, 2))] np.dtype(shape_tuple_dtype) shape_like_dtype = [("R", "u1", (2, 2)), ("G", np.str_, 1)] np.dtype(shape_like_dtype) object_dtype = [("field1", object)] np.dtype(object_dtype) np.dtype((np.int32, (np.int8, 4))) # Dtype comparison np.dtype(float) == float np.dtype(float) != np.float64 np.dtype(float) < None np.dtype(float) <= "float64" np.dtype(float) > np.dtype(float) np.dtype(float) >= np.dtype(("U", 10)) # Iteration and indexing def iterable_func(x): # type: (Iterable) -> Iterable return x iterable_func(array) [element for element in array] iter(array) zip(array, array) array[1] array[:] array[...] array[:] = 0 array_2d = np.ones((3, 3)) array_2d[:2, :2] array_2d[..., 0] array_2d[:2, :2] = 0 # Other special methods len(array) str(array) array_scalar = np.array(1) int(array_scalar) float(array_scalar) # currently does not work due to https://github.com/python/typeshed/issues/1904 # complex(array_scalar) bytes(array_scalar) operator.index(array_scalar) bool(array_scalar) # comparisons array < 1 array <= 1 array == 1 array != 1 array > 1 array >= 1 1 < array 1 <= array 1 == array 1 != array 1 > array 1 >= array # binary arithmetic array + 1 1 + array array += 1 array - 1 1 - array array -= 1 array * 1 1 * array array *= 1 nonzero_array = np.array([1, 2]) array / 1 1 / nonzero_array float_array = np.array([1.0, 2.0]) float_array /= 1 array // 1 1 // nonzero_array array //= 1 array % 1 1 % nonzero_array array %= 1 divmod(array, 1) divmod(1, nonzero_array) array ** 1 1 ** array array **= 1 array << 1 1 << array array <<= 1 array >> 1 1 >> array array >>= 1 array & 1 1 & array array &= 1 array ^ 1 1 ^ array array ^= 1 array | 1 1 | array array |= 1 # unary arithmetic -array +array abs(array) ~array # Other methods np.array([1, 2]).transpose() PKIZzT``data/pass/simple_py3.pynu[import numpy as np array = np.array([1, 2]) # The @ operator is not in python 2 array @ array PKIZj7``data/pass/ufunc_config.pynu["""Typing tests for `numpy.core._ufunc_config`.""" import numpy as np def func1(a: str, b: int) -> None: ... def func2(a: str, b: int, c: float = ...) -> None: ... def func3(a: str, b: int) -> int: ... class Write1: def write(self, a: str) -> None: ... class Write2: def write(self, a: str, b: int = ...) -> None: ... class Write3: def write(self, a: str) -> int: ... _err_default = np.geterr() _bufsize_default = np.getbufsize() _errcall_default = np.geterrcall() try: np.seterr(all=None) np.seterr(divide="ignore") np.seterr(over="warn") np.seterr(under="call") np.seterr(invalid="raise") np.geterr() np.setbufsize(4096) np.getbufsize() np.seterrcall(func1) np.seterrcall(func2) np.seterrcall(func3) np.seterrcall(Write1()) np.seterrcall(Write2()) np.seterrcall(Write3()) np.geterrcall() with np.errstate(call=func1, all="call"): pass with np.errstate(call=Write1(), divide="log", over="log"): pass finally: np.seterr(**_err_default) np.setbufsize(_bufsize_default) np.seterrcall(_errcall_default) PKIZ3data/pass/ufunclike.pynu[from __future__ import annotations from typing import Any import numpy as np class Object: def __ceil__(self) -> Object: return self def __floor__(self) -> Object: return self def __ge__(self, value: object) -> bool: return True def __array__(self) -> np.ndarray[Any, np.dtype[np.object_]]: ret = np.empty((), dtype=object) ret[()] = self return ret AR_LIKE_b = [True, True, False] AR_LIKE_u = [np.uint32(1), np.uint32(2), np.uint32(3)] AR_LIKE_i = [1, 2, 3] AR_LIKE_f = [1.0, 2.0, 3.0] AR_LIKE_O = [Object(), Object(), Object()] AR_U: np.ndarray[Any, np.dtype[np.str_]] = np.zeros(3, dtype="U5") np.fix(AR_LIKE_b) np.fix(AR_LIKE_u) np.fix(AR_LIKE_i) np.fix(AR_LIKE_f) np.fix(AR_LIKE_O) np.fix(AR_LIKE_f, out=AR_U) np.isposinf(AR_LIKE_b) np.isposinf(AR_LIKE_u) np.isposinf(AR_LIKE_i) np.isposinf(AR_LIKE_f) np.isposinf(AR_LIKE_f, out=AR_U) np.isneginf(AR_LIKE_b) np.isneginf(AR_LIKE_u) np.isneginf(AR_LIKE_i) np.isneginf(AR_LIKE_f) np.isneginf(AR_LIKE_f, out=AR_U) PKIZdata/pass/ufuncs.pynu[import numpy as np np.sin(1) np.sin([1, 2, 3]) np.sin(1, out=np.empty(1)) np.matmul(np.ones((2, 2, 2)), np.ones((2, 2, 2)), axes=[(0, 1), (0, 1), (0, 1)]) np.sin(1, signature="D->D") np.sin(1, extobj=[16, 1, lambda: None]) # NOTE: `np.generic` subclasses are not guaranteed to support addition; # re-enable this we can infer the exact return type of `np.sin(...)`. # # np.sin(1) + np.sin(1) np.sin.types[0] np.sin.__name__ np.sin.__doc__ np.abs(np.array([1])) PKIZ/ data/pass/warnings_and_errors.pynu[import numpy as np np.AxisError("test") np.AxisError(1, ndim=2) np.AxisError(1, ndim=2, msg_prefix="error") np.AxisError(1, ndim=2, msg_prefix=None) PKIZsEQEQdata/reveal/arithmetic.pyinu[from typing import Any import numpy as np from numpy._typing import NDArray, _128Bit # Can't directly import `np.float128` as it is not available on all platforms f16: np.floating[_128Bit] c16 = np.complex128() f8 = np.float64() i8 = np.int64() u8 = np.uint64() c8 = np.complex64() f4 = np.float32() i4 = np.int32() u4 = np.uint32() dt = np.datetime64(0, "D") td = np.timedelta64(0, "D") b_ = np.bool_() b = bool() c = complex() f = float() i = int() AR_b: np.ndarray[Any, np.dtype[np.bool_]] AR_u: np.ndarray[Any, np.dtype[np.uint32]] AR_i: np.ndarray[Any, np.dtype[np.int64]] AR_f: np.ndarray[Any, np.dtype[np.float64]] AR_c: np.ndarray[Any, np.dtype[np.complex128]] AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] AR_M: np.ndarray[Any, np.dtype[np.datetime64]] AR_O: np.ndarray[Any, np.dtype[np.object_]] AR_number: NDArray[np.number[Any]] AR_LIKE_b: list[bool] AR_LIKE_u: list[np.uint32] AR_LIKE_i: list[int] AR_LIKE_f: list[float] AR_LIKE_c: list[complex] AR_LIKE_m: list[np.timedelta64] AR_LIKE_M: list[np.datetime64] AR_LIKE_O: list[np.object_] # Array subtraction reveal_type(AR_number - AR_number) # E: ndarray[Any, dtype[number[Any]]] reveal_type(AR_b - AR_LIKE_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_b - AR_LIKE_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_b - AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_b - AR_LIKE_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_b - AR_LIKE_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_b - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_u - AR_b) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_LIKE_i - AR_b) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_f - AR_b) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_c - AR_b) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_m - AR_b) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_M - AR_b) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_LIKE_O - AR_b) # E: Any reveal_type(AR_u - AR_LIKE_b) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_u - AR_LIKE_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_u - AR_LIKE_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_u - AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_u - AR_LIKE_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_u - AR_LIKE_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_u - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b - AR_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_LIKE_u - AR_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_LIKE_i - AR_u) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_f - AR_u) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_c - AR_u) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_m - AR_u) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_M - AR_u) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_LIKE_O - AR_u) # E: Any reveal_type(AR_i - AR_LIKE_b) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_i - AR_LIKE_u) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_i - AR_LIKE_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_i - AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_i - AR_LIKE_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_i - AR_LIKE_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_i - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b - AR_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_u - AR_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_i - AR_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_f - AR_i) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_c - AR_i) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_m - AR_i) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_M - AR_i) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_LIKE_O - AR_i) # E: Any reveal_type(AR_f - AR_LIKE_b) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f - AR_LIKE_u) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f - AR_LIKE_i) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f - AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f - AR_LIKE_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_f - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b - AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_u - AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_i - AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_f - AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_c - AR_f) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_O - AR_f) # E: Any reveal_type(AR_c - AR_LIKE_b) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_c - AR_LIKE_u) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_c - AR_LIKE_i) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_c - AR_LIKE_f) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_c - AR_LIKE_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_c - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b - AR_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_u - AR_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_i - AR_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_f - AR_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_c - AR_c) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(AR_LIKE_O - AR_c) # E: Any reveal_type(AR_m - AR_LIKE_b) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m - AR_LIKE_u) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m - AR_LIKE_i) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m - AR_LIKE_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b - AR_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_u - AR_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_i - AR_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_m - AR_m) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_M - AR_m) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_LIKE_O - AR_m) # E: Any reveal_type(AR_M - AR_LIKE_b) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_M - AR_LIKE_u) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_M - AR_LIKE_i) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_M - AR_LIKE_m) # E: ndarray[Any, dtype[datetime64]] reveal_type(AR_M - AR_LIKE_M) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_M - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_M - AR_M) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_O - AR_M) # E: Any reveal_type(AR_O - AR_LIKE_b) # E: Any reveal_type(AR_O - AR_LIKE_u) # E: Any reveal_type(AR_O - AR_LIKE_i) # E: Any reveal_type(AR_O - AR_LIKE_f) # E: Any reveal_type(AR_O - AR_LIKE_c) # E: Any reveal_type(AR_O - AR_LIKE_m) # E: Any reveal_type(AR_O - AR_LIKE_M) # E: Any reveal_type(AR_O - AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b - AR_O) # E: Any reveal_type(AR_LIKE_u - AR_O) # E: Any reveal_type(AR_LIKE_i - AR_O) # E: Any reveal_type(AR_LIKE_f - AR_O) # E: Any reveal_type(AR_LIKE_c - AR_O) # E: Any reveal_type(AR_LIKE_m - AR_O) # E: Any reveal_type(AR_LIKE_M - AR_O) # E: Any reveal_type(AR_LIKE_O - AR_O) # E: Any # Array floor division reveal_type(AR_b // AR_LIKE_b) # E: ndarray[Any, dtype[{int8}]] reveal_type(AR_b // AR_LIKE_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_b // AR_LIKE_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_b // AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_b // AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b // AR_b) # E: ndarray[Any, dtype[{int8}]] reveal_type(AR_LIKE_u // AR_b) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_LIKE_i // AR_b) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_f // AR_b) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_O // AR_b) # E: Any reveal_type(AR_u // AR_LIKE_b) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_u // AR_LIKE_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_u // AR_LIKE_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_u // AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_u // AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b // AR_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_LIKE_u // AR_u) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(AR_LIKE_i // AR_u) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_f // AR_u) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_m // AR_u) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_O // AR_u) # E: Any reveal_type(AR_i // AR_LIKE_b) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_i // AR_LIKE_u) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_i // AR_LIKE_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_i // AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_i // AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b // AR_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_u // AR_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_i // AR_i) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(AR_LIKE_f // AR_i) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_m // AR_i) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_O // AR_i) # E: Any reveal_type(AR_f // AR_LIKE_b) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f // AR_LIKE_u) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f // AR_LIKE_i) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f // AR_LIKE_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_f // AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b // AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_u // AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_i // AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_f // AR_f) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(AR_LIKE_m // AR_f) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_LIKE_O // AR_f) # E: Any reveal_type(AR_m // AR_LIKE_u) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m // AR_LIKE_i) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m // AR_LIKE_f) # E: ndarray[Any, dtype[timedelta64]] reveal_type(AR_m // AR_LIKE_m) # E: ndarray[Any, dtype[{int64}]] reveal_type(AR_m // AR_LIKE_O) # E: Any reveal_type(AR_LIKE_m // AR_m) # E: ndarray[Any, dtype[{int64}]] reveal_type(AR_LIKE_O // AR_m) # E: Any reveal_type(AR_O // AR_LIKE_b) # E: Any reveal_type(AR_O // AR_LIKE_u) # E: Any reveal_type(AR_O // AR_LIKE_i) # E: Any reveal_type(AR_O // AR_LIKE_f) # E: Any reveal_type(AR_O // AR_LIKE_m) # E: Any reveal_type(AR_O // AR_LIKE_M) # E: Any reveal_type(AR_O // AR_LIKE_O) # E: Any reveal_type(AR_LIKE_b // AR_O) # E: Any reveal_type(AR_LIKE_u // AR_O) # E: Any reveal_type(AR_LIKE_i // AR_O) # E: Any reveal_type(AR_LIKE_f // AR_O) # E: Any reveal_type(AR_LIKE_m // AR_O) # E: Any reveal_type(AR_LIKE_M // AR_O) # E: Any reveal_type(AR_LIKE_O // AR_O) # E: Any # unary ops reveal_type(-f16) # E: {float128} reveal_type(-c16) # E: {complex128} reveal_type(-c8) # E: {complex64} reveal_type(-f8) # E: {float64} reveal_type(-f4) # E: {float32} reveal_type(-i8) # E: {int64} reveal_type(-i4) # E: {int32} reveal_type(-u8) # E: {uint64} reveal_type(-u4) # E: {uint32} reveal_type(-td) # E: timedelta64 reveal_type(-AR_f) # E: Any reveal_type(+f16) # E: {float128} reveal_type(+c16) # E: {complex128} reveal_type(+c8) # E: {complex64} reveal_type(+f8) # E: {float64} reveal_type(+f4) # E: {float32} reveal_type(+i8) # E: {int64} reveal_type(+i4) # E: {int32} reveal_type(+u8) # E: {uint64} reveal_type(+u4) # E: {uint32} reveal_type(+td) # E: timedelta64 reveal_type(+AR_f) # E: Any reveal_type(abs(f16)) # E: {float128} reveal_type(abs(c16)) # E: {float64} reveal_type(abs(c8)) # E: {float32} reveal_type(abs(f8)) # E: {float64} reveal_type(abs(f4)) # E: {float32} reveal_type(abs(i8)) # E: {int64} reveal_type(abs(i4)) # E: {int32} reveal_type(abs(u8)) # E: {uint64} reveal_type(abs(u4)) # E: {uint32} reveal_type(abs(td)) # E: timedelta64 reveal_type(abs(b_)) # E: bool_ reveal_type(abs(AR_f)) # E: Any # Time structures reveal_type(dt + td) # E: datetime64 reveal_type(dt + i) # E: datetime64 reveal_type(dt + i4) # E: datetime64 reveal_type(dt + i8) # E: datetime64 reveal_type(dt - dt) # E: timedelta64 reveal_type(dt - i) # E: datetime64 reveal_type(dt - i4) # E: datetime64 reveal_type(dt - i8) # E: datetime64 reveal_type(td + td) # E: timedelta64 reveal_type(td + i) # E: timedelta64 reveal_type(td + i4) # E: timedelta64 reveal_type(td + i8) # E: timedelta64 reveal_type(td - td) # E: timedelta64 reveal_type(td - i) # E: timedelta64 reveal_type(td - i4) # E: timedelta64 reveal_type(td - i8) # E: timedelta64 reveal_type(td / f) # E: timedelta64 reveal_type(td / f4) # E: timedelta64 reveal_type(td / f8) # E: timedelta64 reveal_type(td / td) # E: {float64} reveal_type(td // td) # E: {int64} # boolean reveal_type(b_ / b) # E: {float64} reveal_type(b_ / b_) # E: {float64} reveal_type(b_ / i) # E: {float64} reveal_type(b_ / i8) # E: {float64} reveal_type(b_ / i4) # E: {float64} reveal_type(b_ / u8) # E: {float64} reveal_type(b_ / u4) # E: {float64} reveal_type(b_ / f) # E: {float64} reveal_type(b_ / f16) # E: {float128} reveal_type(b_ / f8) # E: {float64} reveal_type(b_ / f4) # E: {float32} reveal_type(b_ / c) # E: {complex128} reveal_type(b_ / c16) # E: {complex128} reveal_type(b_ / c8) # E: {complex64} reveal_type(b / b_) # E: {float64} reveal_type(b_ / b_) # E: {float64} reveal_type(i / b_) # E: {float64} reveal_type(i8 / b_) # E: {float64} reveal_type(i4 / b_) # E: {float64} reveal_type(u8 / b_) # E: {float64} reveal_type(u4 / b_) # E: {float64} reveal_type(f / b_) # E: {float64} reveal_type(f16 / b_) # E: {float128} reveal_type(f8 / b_) # E: {float64} reveal_type(f4 / b_) # E: {float32} reveal_type(c / b_) # E: {complex128} reveal_type(c16 / b_) # E: {complex128} reveal_type(c8 / b_) # E: {complex64} # Complex reveal_type(c16 + f16) # E: {complex256} reveal_type(c16 + c16) # E: {complex128} reveal_type(c16 + f8) # E: {complex128} reveal_type(c16 + i8) # E: {complex128} reveal_type(c16 + c8) # E: {complex128} reveal_type(c16 + f4) # E: {complex128} reveal_type(c16 + i4) # E: {complex128} reveal_type(c16 + b_) # E: {complex128} reveal_type(c16 + b) # E: {complex128} reveal_type(c16 + c) # E: {complex128} reveal_type(c16 + f) # E: {complex128} reveal_type(c16 + i) # E: {complex128} reveal_type(c16 + AR_f) # E: Any reveal_type(f16 + c16) # E: {complex256} reveal_type(c16 + c16) # E: {complex128} reveal_type(f8 + c16) # E: {complex128} reveal_type(i8 + c16) # E: {complex128} reveal_type(c8 + c16) # E: {complex128} reveal_type(f4 + c16) # E: {complex128} reveal_type(i4 + c16) # E: {complex128} reveal_type(b_ + c16) # E: {complex128} reveal_type(b + c16) # E: {complex128} reveal_type(c + c16) # E: {complex128} reveal_type(f + c16) # E: {complex128} reveal_type(i + c16) # E: {complex128} reveal_type(AR_f + c16) # E: Any reveal_type(c8 + f16) # E: {complex256} reveal_type(c8 + c16) # E: {complex128} reveal_type(c8 + f8) # E: {complex128} reveal_type(c8 + i8) # E: {complex128} reveal_type(c8 + c8) # E: {complex64} reveal_type(c8 + f4) # E: {complex64} reveal_type(c8 + i4) # E: {complex64} reveal_type(c8 + b_) # E: {complex64} reveal_type(c8 + b) # E: {complex64} reveal_type(c8 + c) # E: {complex128} reveal_type(c8 + f) # E: {complex128} reveal_type(c8 + i) # E: complexfloating[{_NBitInt}, {_NBitInt}] reveal_type(c8 + AR_f) # E: Any reveal_type(f16 + c8) # E: {complex256} reveal_type(c16 + c8) # E: {complex128} reveal_type(f8 + c8) # E: {complex128} reveal_type(i8 + c8) # E: {complex128} reveal_type(c8 + c8) # E: {complex64} reveal_type(f4 + c8) # E: {complex64} reveal_type(i4 + c8) # E: {complex64} reveal_type(b_ + c8) # E: {complex64} reveal_type(b + c8) # E: {complex64} reveal_type(c + c8) # E: {complex128} reveal_type(f + c8) # E: {complex128} reveal_type(i + c8) # E: complexfloating[{_NBitInt}, {_NBitInt}] reveal_type(AR_f + c8) # E: Any # Float reveal_type(f8 + f16) # E: {float128} reveal_type(f8 + f8) # E: {float64} reveal_type(f8 + i8) # E: {float64} reveal_type(f8 + f4) # E: {float64} reveal_type(f8 + i4) # E: {float64} reveal_type(f8 + b_) # E: {float64} reveal_type(f8 + b) # E: {float64} reveal_type(f8 + c) # E: {complex128} reveal_type(f8 + f) # E: {float64} reveal_type(f8 + i) # E: {float64} reveal_type(f8 + AR_f) # E: Any reveal_type(f16 + f8) # E: {float128} reveal_type(f8 + f8) # E: {float64} reveal_type(i8 + f8) # E: {float64} reveal_type(f4 + f8) # E: {float64} reveal_type(i4 + f8) # E: {float64} reveal_type(b_ + f8) # E: {float64} reveal_type(b + f8) # E: {float64} reveal_type(c + f8) # E: {complex128} reveal_type(f + f8) # E: {float64} reveal_type(i + f8) # E: {float64} reveal_type(AR_f + f8) # E: Any reveal_type(f4 + f16) # E: {float128} reveal_type(f4 + f8) # E: {float64} reveal_type(f4 + i8) # E: {float64} reveal_type(f4 + f4) # E: {float32} reveal_type(f4 + i4) # E: {float32} reveal_type(f4 + b_) # E: {float32} reveal_type(f4 + b) # E: {float32} reveal_type(f4 + c) # E: {complex128} reveal_type(f4 + f) # E: {float64} reveal_type(f4 + i) # E: floating[{_NBitInt}] reveal_type(f4 + AR_f) # E: Any reveal_type(f16 + f4) # E: {float128} reveal_type(f8 + f4) # E: {float64} reveal_type(i8 + f4) # E: {float64} reveal_type(f4 + f4) # E: {float32} reveal_type(i4 + f4) # E: {float32} reveal_type(b_ + f4) # E: {float32} reveal_type(b + f4) # E: {float32} reveal_type(c + f4) # E: {complex128} reveal_type(f + f4) # E: {float64} reveal_type(i + f4) # E: floating[{_NBitInt}] reveal_type(AR_f + f4) # E: Any # Int reveal_type(i8 + i8) # E: {int64} reveal_type(i8 + u8) # E: Any reveal_type(i8 + i4) # E: {int64} reveal_type(i8 + u4) # E: Any reveal_type(i8 + b_) # E: {int64} reveal_type(i8 + b) # E: {int64} reveal_type(i8 + c) # E: {complex128} reveal_type(i8 + f) # E: {float64} reveal_type(i8 + i) # E: {int64} reveal_type(i8 + AR_f) # E: Any reveal_type(u8 + u8) # E: {uint64} reveal_type(u8 + i4) # E: Any reveal_type(u8 + u4) # E: {uint64} reveal_type(u8 + b_) # E: {uint64} reveal_type(u8 + b) # E: {uint64} reveal_type(u8 + c) # E: {complex128} reveal_type(u8 + f) # E: {float64} reveal_type(u8 + i) # E: Any reveal_type(u8 + AR_f) # E: Any reveal_type(i8 + i8) # E: {int64} reveal_type(u8 + i8) # E: Any reveal_type(i4 + i8) # E: {int64} reveal_type(u4 + i8) # E: Any reveal_type(b_ + i8) # E: {int64} reveal_type(b + i8) # E: {int64} reveal_type(c + i8) # E: {complex128} reveal_type(f + i8) # E: {float64} reveal_type(i + i8) # E: {int64} reveal_type(AR_f + i8) # E: Any reveal_type(u8 + u8) # E: {uint64} reveal_type(i4 + u8) # E: Any reveal_type(u4 + u8) # E: {uint64} reveal_type(b_ + u8) # E: {uint64} reveal_type(b + u8) # E: {uint64} reveal_type(c + u8) # E: {complex128} reveal_type(f + u8) # E: {float64} reveal_type(i + u8) # E: Any reveal_type(AR_f + u8) # E: Any reveal_type(i4 + i8) # E: {int64} reveal_type(i4 + i4) # E: {int32} reveal_type(i4 + i) # E: {int_} reveal_type(i4 + b_) # E: {int32} reveal_type(i4 + b) # E: {int32} reveal_type(i4 + AR_f) # E: Any reveal_type(u4 + i8) # E: Any reveal_type(u4 + i4) # E: Any reveal_type(u4 + u8) # E: {uint64} reveal_type(u4 + u4) # E: {uint32} reveal_type(u4 + i) # E: Any reveal_type(u4 + b_) # E: {uint32} reveal_type(u4 + b) # E: {uint32} reveal_type(u4 + AR_f) # E: Any reveal_type(i8 + i4) # E: {int64} reveal_type(i4 + i4) # E: {int32} reveal_type(i + i4) # E: {int_} reveal_type(b_ + i4) # E: {int32} reveal_type(b + i4) # E: {int32} reveal_type(AR_f + i4) # E: Any reveal_type(i8 + u4) # E: Any reveal_type(i4 + u4) # E: Any reveal_type(u8 + u4) # E: {uint64} reveal_type(u4 + u4) # E: {uint32} reveal_type(b_ + u4) # E: {uint32} reveal_type(b + u4) # E: {uint32} reveal_type(i + u4) # E: Any reveal_type(AR_f + u4) # E: Any PKIZƻg g data/reveal/ufuncs.pyinu[import numpy as np import numpy.typing as npt f8: np.float64 AR_f8: npt.NDArray[np.float64] AR_i8: npt.NDArray[np.int64] reveal_type(np.absolute.__doc__) # E: str reveal_type(np.absolute.types) # E: builtins.list[builtins.str] reveal_type(np.absolute.__name__) # E: Literal['absolute'] reveal_type(np.absolute.ntypes) # E: Literal[20] reveal_type(np.absolute.identity) # E: None reveal_type(np.absolute.nin) # E: Literal[1] reveal_type(np.absolute.nin) # E: Literal[1] reveal_type(np.absolute.nout) # E: Literal[1] reveal_type(np.absolute.nargs) # E: Literal[2] reveal_type(np.absolute.signature) # E: None reveal_type(np.absolute(f8)) # E: Any reveal_type(np.absolute(AR_f8)) # E: ndarray reveal_type(np.absolute.at(AR_f8, AR_i8)) # E: None reveal_type(np.add.__name__) # E: Literal['add'] reveal_type(np.add.ntypes) # E: Literal[22] reveal_type(np.add.identity) # E: Literal[0] reveal_type(np.add.nin) # E: Literal[2] reveal_type(np.add.nout) # E: Literal[1] reveal_type(np.add.nargs) # E: Literal[3] reveal_type(np.add.signature) # E: None reveal_type(np.add(f8, f8)) # E: Any reveal_type(np.add(AR_f8, f8)) # E: ndarray reveal_type(np.add.at(AR_f8, AR_i8, f8)) # E: None reveal_type(np.add.reduce(AR_f8, axis=0)) # E: Any reveal_type(np.add.accumulate(AR_f8)) # E: ndarray reveal_type(np.add.reduceat(AR_f8, AR_i8)) # E: ndarray reveal_type(np.add.outer(f8, f8)) # E: Any reveal_type(np.add.outer(AR_f8, f8)) # E: ndarray reveal_type(np.frexp.__name__) # E: Literal['frexp'] reveal_type(np.frexp.ntypes) # E: Literal[4] reveal_type(np.frexp.identity) # E: None reveal_type(np.frexp.nin) # E: Literal[1] reveal_type(np.frexp.nout) # E: Literal[2] reveal_type(np.frexp.nargs) # E: Literal[3] reveal_type(np.frexp.signature) # E: None reveal_type(np.frexp(f8)) # E: Tuple[Any, Any] reveal_type(np.frexp(AR_f8)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] reveal_type(np.divmod.__name__) # E: Literal['divmod'] reveal_type(np.divmod.ntypes) # E: Literal[15] reveal_type(np.divmod.identity) # E: None reveal_type(np.divmod.nin) # E: Literal[2] reveal_type(np.divmod.nout) # E: Literal[2] reveal_type(np.divmod.nargs) # E: Literal[4] reveal_type(np.divmod.signature) # E: None reveal_type(np.divmod(f8, f8)) # E: Tuple[Any, Any] reveal_type(np.divmod(AR_f8, f8)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] reveal_type(np.matmul.__name__) # E: Literal['matmul'] reveal_type(np.matmul.ntypes) # E: Literal[19] reveal_type(np.matmul.identity) # E: None reveal_type(np.matmul.nin) # E: Literal[2] reveal_type(np.matmul.nout) # E: Literal[1] reveal_type(np.matmul.nargs) # E: Literal[3] reveal_type(np.matmul.signature) # E: Literal['(n?,k),(k,m?)->(n?,m?)'] reveal_type(np.matmul.identity) # E: None reveal_type(np.matmul(AR_f8, AR_f8)) # E: Any reveal_type(np.matmul(AR_f8, AR_f8, axes=[(0, 1), (0, 1), (0, 1)])) # E: Any PKIZ7.7."data/reveal/array_constructors.pyinu[from typing import Any, TypeVar from pathlib import Path import numpy as np import numpy.typing as npt _SCT = TypeVar("_SCT", bound=np.generic, covariant=True) class SubClass(np.ndarray[Any, np.dtype[_SCT]]): ... i8: np.int64 A: npt.NDArray[np.float64] B: SubClass[np.float64] C: list[int] def func(i: int, j: int, **kwargs: Any) -> SubClass[np.float64]: ... reveal_type(np.empty_like(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.empty_like(B)) # E: SubClass[{float64}] reveal_type(np.empty_like([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.empty_like(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.empty_like(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.array(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.array(B)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.array(B, subok=True)) # E: SubClass[{float64}] reveal_type(np.array([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.array(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.array(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.array(A, like=A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.zeros([1, 5, 6])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.zeros([1, 5, 6], dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.zeros([1, 5, 6], dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.empty([1, 5, 6])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.empty([1, 5, 6], dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.empty([1, 5, 6], dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.concatenate(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.concatenate([A, A])) # E: Any reveal_type(np.concatenate([[1], A])) # E: ndarray[Any, dtype[Any]] reveal_type(np.concatenate([[1], [1]])) # E: ndarray[Any, dtype[Any]] reveal_type(np.concatenate((A, A))) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.concatenate(([1], [1]))) # E: ndarray[Any, dtype[Any]] reveal_type(np.concatenate([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.concatenate(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.concatenate(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.concatenate([1, 1.0], out=A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asarray(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asarray(B)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asarray([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.asarray(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.asarray(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.asanyarray(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asanyarray(B)) # E: SubClass[{float64}] reveal_type(np.asanyarray([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.asanyarray(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.asanyarray(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.ascontiguousarray(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.ascontiguousarray(B)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.ascontiguousarray([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.ascontiguousarray(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.ascontiguousarray(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.asfortranarray(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asfortranarray(B)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asfortranarray([1, 1.0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.asfortranarray(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.asfortranarray(A, dtype='c16')) # E: ndarray[Any, dtype[Any]] reveal_type(np.fromstring("1 1 1", sep=" ")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromstring(b"1 1 1", sep=" ")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromstring("1 1 1", dtype=np.int64, sep=" ")) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.fromstring(b"1 1 1", dtype=np.int64, sep=" ")) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.fromstring("1 1 1", dtype="c16", sep=" ")) # E: ndarray[Any, dtype[Any]] reveal_type(np.fromstring(b"1 1 1", dtype="c16", sep=" ")) # E: ndarray[Any, dtype[Any]] reveal_type(np.fromfile("test.txt", sep=" ")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromfile("test.txt", dtype=np.int64, sep=" ")) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.fromfile("test.txt", dtype="c16", sep=" ")) # E: ndarray[Any, dtype[Any]] with open("test.txt") as f: reveal_type(np.fromfile(f, sep=" ")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromfile(b"test.txt", sep=" ")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromfile(Path("test.txt"), sep=" ")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromiter("12345", np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromiter("12345", float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.frombuffer(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.frombuffer(A, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.frombuffer(A, dtype="c16")) # E: ndarray[Any, dtype[Any]] reveal_type(np.arange(False, True)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.arange(10)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.arange(0, 10, step=2)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.arange(10.0)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.arange(start=0, stop=10.0)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.arange(np.timedelta64(0))) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.arange(0, np.timedelta64(10))) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.arange(np.datetime64("0"), np.datetime64("10"))) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.arange(10, dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.arange(0, 10, step=2, dtype=np.int16)) # E: ndarray[Any, dtype[{int16}]] reveal_type(np.arange(10, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.arange(0, 10, dtype="f8")) # E: ndarray[Any, dtype[Any]] reveal_type(np.require(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.require(B)) # E: SubClass[{float64}] reveal_type(np.require(B, requirements=None)) # E: SubClass[{float64}] reveal_type(np.require(B, dtype=int)) # E: ndarray[Any, Any] reveal_type(np.require(B, requirements="E")) # E: ndarray[Any, Any] reveal_type(np.require(B, requirements=["ENSUREARRAY"])) # E: ndarray[Any, Any] reveal_type(np.require(B, requirements={"F", "E"})) # E: ndarray[Any, Any] reveal_type(np.require(B, requirements=["C", "OWNDATA"])) # E: SubClass[{float64}] reveal_type(np.require(B, requirements="W")) # E: SubClass[{float64}] reveal_type(np.require(B, requirements="A")) # E: SubClass[{float64}] reveal_type(np.require(C)) # E: ndarray[Any, Any] reveal_type(np.linspace(0, 10)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linspace(0, 10j)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linspace(0, 10, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.linspace(0, 10, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.linspace(0, 10, retstep=True)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], floating[Any]] reveal_type(np.linspace(0j, 10, retstep=True)) # E: Tuple[ndarray[Any, dtype[complexfloating[Any, Any]]], complexfloating[Any, Any]] reveal_type(np.linspace(0, 10, retstep=True, dtype=np.int64)) # E: Tuple[ndarray[Any, dtype[{int64}]], {int64}] reveal_type(np.linspace(0j, 10, retstep=True, dtype=int)) # E: Tuple[ndarray[Any, dtype[Any]], Any] reveal_type(np.logspace(0, 10)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.logspace(0, 10j)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.logspace(0, 10, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.logspace(0, 10, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.geomspace(0, 10)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.geomspace(0, 10j)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.geomspace(0, 10, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.geomspace(0, 10, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.zeros_like(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.zeros_like(C)) # E: ndarray[Any, dtype[Any]] reveal_type(np.zeros_like(A, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.zeros_like(B)) # E: SubClass[{float64}] reveal_type(np.zeros_like(B, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.ones_like(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.ones_like(C)) # E: ndarray[Any, dtype[Any]] reveal_type(np.ones_like(A, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.ones_like(B)) # E: SubClass[{float64}] reveal_type(np.ones_like(B, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.full_like(A, i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.full_like(C, i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.full_like(A, i8, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.full_like(B, i8)) # E: SubClass[{float64}] reveal_type(np.full_like(B, i8, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.ones(1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.ones([1, 1, 1])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.ones(5, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.ones(5, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.full(1, i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.full([1, 1, 1], i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.full(1, i8, dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.full(1, i8, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.indices([1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.indices([1, 2, 3], sparse=True)) # E: tuple[ndarray[Any, dtype[{int_}]], ...] reveal_type(np.fromfunction(func, (3, 5))) # E: SubClass[{float64}] reveal_type(np.identity(10)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.identity(10, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.identity(10, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.atleast_1d(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.atleast_1d(C)) # E: ndarray[Any, dtype[Any]] reveal_type(np.atleast_1d(A, A)) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.atleast_1d(A, C)) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.atleast_1d(C, C)) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.atleast_2d(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.atleast_3d(A)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.vstack([A, A])) # E: ndarray[Any, Any] reveal_type(np.vstack([A, A], dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.vstack([A, C])) # E: ndarray[Any, dtype[Any]] reveal_type(np.vstack([C, C])) # E: ndarray[Any, dtype[Any]] reveal_type(np.hstack([A, A])) # E: ndarray[Any, Any] reveal_type(np.hstack([A, A], dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.stack([A, A])) # E: Any reveal_type(np.stack([A, A], dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.stack([A, C])) # E: ndarray[Any, dtype[Any]] reveal_type(np.stack([C, C])) # E: ndarray[Any, dtype[Any]] reveal_type(np.stack([A, A], axis=0)) # E: Any reveal_type(np.stack([A, A], out=B)) # E: SubClass[{float64}] reveal_type(np.block([[A, A], [A, A]])) # E: ndarray[Any, dtype[Any]] reveal_type(np.block(C)) # E: ndarray[Any, dtype[Any]] PKIZGadata/reveal/arraypad.pyinu[from collections.abc import Mapping from typing import Any, SupportsIndex import numpy as np import numpy.typing as npt def mode_func( ar: npt.NDArray[np.number[Any]], width: tuple[int, int], iaxis: SupportsIndex, kwargs: Mapping[str, Any], ) -> None: ... AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_LIKE: list[int] reveal_type(np.pad(AR_i8, (2, 3), "constant")) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.pad(AR_LIKE, (2, 3), "constant")) # E: ndarray[Any, dtype[Any]] reveal_type(np.pad(AR_f8, (2, 3), mode_func)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.pad(AR_f8, (2, 3), mode_func, a=1, b=2)) # E: ndarray[Any, dtype[{float64}]] PKIZ62Edata/reveal/arrayprint.pyinu[from collections.abc import Callable from typing import Any import numpy as np AR: np.ndarray[Any, Any] func_float: Callable[[np.floating[Any]], str] func_int: Callable[[np.integer[Any]], str] reveal_type(np.get_printoptions()) # E: TypedDict reveal_type(np.array2string( # E: str AR, formatter={'float_kind': func_float, 'int_kind': func_int} )) reveal_type(np.format_float_scientific(1.0)) # E: str reveal_type(np.format_float_positional(1)) # E: str reveal_type(np.array_repr(AR)) # E: str reveal_type(np.array_str(AR)) # E: str reveal_type(np.printoptions()) # E: contextlib._GeneratorContextManager with np.printoptions() as dct: reveal_type(dct) # E: TypedDict PKIZJ]??data/reveal/arraysetops.pyinu[import numpy as np import numpy.typing as npt AR_b: npt.NDArray[np.bool_] AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_M: npt.NDArray[np.datetime64] AR_O: npt.NDArray[np.object_] AR_LIKE_f8: list[float] reveal_type(np.ediff1d(AR_b)) # E: ndarray[Any, dtype[{int8}]] reveal_type(np.ediff1d(AR_i8, to_end=[1, 2, 3])) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.ediff1d(AR_M)) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.ediff1d(AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.ediff1d(AR_LIKE_f8, to_begin=[1, 1.5])) # E: ndarray[Any, dtype[Any]] reveal_type(np.intersect1d(AR_i8, AR_i8)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.intersect1d(AR_M, AR_M, assume_unique=True)) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.intersect1d(AR_f8, AR_i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.intersect1d(AR_f8, AR_f8, return_indices=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.setxor1d(AR_i8, AR_i8)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.setxor1d(AR_M, AR_M, assume_unique=True)) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.setxor1d(AR_f8, AR_i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.in1d(AR_i8, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.in1d(AR_M, AR_M, assume_unique=True)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.in1d(AR_f8, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.in1d(AR_f8, AR_LIKE_f8, invert=True)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isin(AR_i8, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isin(AR_M, AR_M, assume_unique=True)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isin(AR_f8, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isin(AR_f8, AR_LIKE_f8, invert=True)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.union1d(AR_i8, AR_i8)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.union1d(AR_M, AR_M)) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.union1d(AR_f8, AR_i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.setdiff1d(AR_i8, AR_i8)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.setdiff1d(AR_M, AR_M, assume_unique=True)) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.setdiff1d(AR_f8, AR_i8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.unique(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.unique(AR_LIKE_f8, axis=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.unique(AR_f8, return_index=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_index=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_f8, return_inverse=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_inverse=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_f8, return_counts=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_counts=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_f8, return_index=True, return_inverse=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_index=True, return_inverse=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_f8, return_index=True, return_counts=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_index=True, return_counts=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_f8, return_inverse=True, return_counts=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_inverse=True, return_counts=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_f8, return_index=True, return_inverse=True, return_counts=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.unique(AR_LIKE_f8, return_index=True, return_inverse=True, return_counts=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] PKIZW"chhdata/reveal/arrayterator.pyinu[from typing import Any import numpy as np AR_i8: np.ndarray[Any, np.dtype[np.int64]] ar_iter = np.lib.Arrayterator(AR_i8) reveal_type(ar_iter.var) # E: ndarray[Any, dtype[{int64}]] reveal_type(ar_iter.buf_size) # E: Union[None, builtins.int] reveal_type(ar_iter.start) # E: builtins.list[builtins.int] reveal_type(ar_iter.stop) # E: builtins.list[builtins.int] reveal_type(ar_iter.step) # E: builtins.list[builtins.int] reveal_type(ar_iter.shape) # E: builtins.tuple[builtins.int, ...] reveal_type(ar_iter.flat) # E: typing.Generator[{int64}, None, None] reveal_type(ar_iter.__array__()) # E: ndarray[Any, dtype[{int64}]] for i in ar_iter: reveal_type(i) # E: ndarray[Any, dtype[{int64}]] reveal_type(ar_iter[0]) # E: lib.arrayterator.Arrayterator[Any, dtype[{int64}]] reveal_type(ar_iter[...]) # E: lib.arrayterator.Arrayterator[Any, dtype[{int64}]] reveal_type(ar_iter[:]) # E: lib.arrayterator.Arrayterator[Any, dtype[{int64}]] reveal_type(ar_iter[0, 0, 0]) # E: lib.arrayterator.Arrayterator[Any, dtype[{int64}]] reveal_type(ar_iter[..., 0, :]) # E: lib.arrayterator.Arrayterator[Any, dtype[{int64}]] PKIZkdata/reveal/bitwise_ops.pyinu[import numpy as np i8 = np.int64(1) u8 = np.uint64(1) i4 = np.int32(1) u4 = np.uint32(1) b_ = np.bool_(1) b = bool(1) i = int(1) AR = np.array([0, 1, 2], dtype=np.int32) AR.setflags(write=False) reveal_type(i8 << i8) # E: {int64} reveal_type(i8 >> i8) # E: {int64} reveal_type(i8 | i8) # E: {int64} reveal_type(i8 ^ i8) # E: {int64} reveal_type(i8 & i8) # E: {int64} reveal_type(i8 << AR) # E: Any reveal_type(i8 >> AR) # E: Any reveal_type(i8 | AR) # E: Any reveal_type(i8 ^ AR) # E: Any reveal_type(i8 & AR) # E: Any reveal_type(i4 << i4) # E: {int32} reveal_type(i4 >> i4) # E: {int32} reveal_type(i4 | i4) # E: {int32} reveal_type(i4 ^ i4) # E: {int32} reveal_type(i4 & i4) # E: {int32} reveal_type(i8 << i4) # E: {int64} reveal_type(i8 >> i4) # E: {int64} reveal_type(i8 | i4) # E: {int64} reveal_type(i8 ^ i4) # E: {int64} reveal_type(i8 & i4) # E: {int64} reveal_type(i8 << i) # E: {int64} reveal_type(i8 >> i) # E: {int64} reveal_type(i8 | i) # E: {int64} reveal_type(i8 ^ i) # E: {int64} reveal_type(i8 & i) # E: {int64} reveal_type(i8 << b_) # E: {int64} reveal_type(i8 >> b_) # E: {int64} reveal_type(i8 | b_) # E: {int64} reveal_type(i8 ^ b_) # E: {int64} reveal_type(i8 & b_) # E: {int64} reveal_type(i8 << b) # E: {int64} reveal_type(i8 >> b) # E: {int64} reveal_type(i8 | b) # E: {int64} reveal_type(i8 ^ b) # E: {int64} reveal_type(i8 & b) # E: {int64} reveal_type(u8 << u8) # E: {uint64} reveal_type(u8 >> u8) # E: {uint64} reveal_type(u8 | u8) # E: {uint64} reveal_type(u8 ^ u8) # E: {uint64} reveal_type(u8 & u8) # E: {uint64} reveal_type(u8 << AR) # E: Any reveal_type(u8 >> AR) # E: Any reveal_type(u8 | AR) # E: Any reveal_type(u8 ^ AR) # E: Any reveal_type(u8 & AR) # E: Any reveal_type(u4 << u4) # E: {uint32} reveal_type(u4 >> u4) # E: {uint32} reveal_type(u4 | u4) # E: {uint32} reveal_type(u4 ^ u4) # E: {uint32} reveal_type(u4 & u4) # E: {uint32} reveal_type(u4 << i4) # E: signedinteger[Any] reveal_type(u4 >> i4) # E: signedinteger[Any] reveal_type(u4 | i4) # E: signedinteger[Any] reveal_type(u4 ^ i4) # E: signedinteger[Any] reveal_type(u4 & i4) # E: signedinteger[Any] reveal_type(u4 << i) # E: signedinteger[Any] reveal_type(u4 >> i) # E: signedinteger[Any] reveal_type(u4 | i) # E: signedinteger[Any] reveal_type(u4 ^ i) # E: signedinteger[Any] reveal_type(u4 & i) # E: signedinteger[Any] reveal_type(u8 << b_) # E: {uint64} reveal_type(u8 >> b_) # E: {uint64} reveal_type(u8 | b_) # E: {uint64} reveal_type(u8 ^ b_) # E: {uint64} reveal_type(u8 & b_) # E: {uint64} reveal_type(u8 << b) # E: {uint64} reveal_type(u8 >> b) # E: {uint64} reveal_type(u8 | b) # E: {uint64} reveal_type(u8 ^ b) # E: {uint64} reveal_type(u8 & b) # E: {uint64} reveal_type(b_ << b_) # E: {int8} reveal_type(b_ >> b_) # E: {int8} reveal_type(b_ | b_) # E: bool_ reveal_type(b_ ^ b_) # E: bool_ reveal_type(b_ & b_) # E: bool_ reveal_type(b_ << AR) # E: Any reveal_type(b_ >> AR) # E: Any reveal_type(b_ | AR) # E: Any reveal_type(b_ ^ AR) # E: Any reveal_type(b_ & AR) # E: Any reveal_type(b_ << b) # E: {int8} reveal_type(b_ >> b) # E: {int8} reveal_type(b_ | b) # E: bool_ reveal_type(b_ ^ b) # E: bool_ reveal_type(b_ & b) # E: bool_ reveal_type(b_ << i) # E: {int_} reveal_type(b_ >> i) # E: {int_} reveal_type(b_ | i) # E: {int_} reveal_type(b_ ^ i) # E: {int_} reveal_type(b_ & i) # E: {int_} reveal_type(~i8) # E: {int64} reveal_type(~i4) # E: {int32} reveal_type(~u8) # E: {uint64} reveal_type(~u4) # E: {uint32} reveal_type(~b_) # E: bool_ reveal_type(~AR) # E: Any PKIZk=oodata/reveal/char.pyinu[import numpy as np import numpy.typing as npt from collections.abc import Sequence AR_U: npt.NDArray[np.str_] AR_S: npt.NDArray[np.bytes_] reveal_type(np.char.equal(AR_U, AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.equal(AR_S, AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.not_equal(AR_U, AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.not_equal(AR_S, AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.greater_equal(AR_U, AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.greater_equal(AR_S, AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.less_equal(AR_U, AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.less_equal(AR_S, AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.greater(AR_U, AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.greater(AR_S, AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.less(AR_U, AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.less(AR_S, AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.multiply(AR_U, 5)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.multiply(AR_S, [5, 4, 3])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.mod(AR_U, "test")) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.mod(AR_S, "test")) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.capitalize(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.capitalize(AR_S)) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.center(AR_U, 5)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.center(AR_S, [2, 3, 4], b"a")) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.encode(AR_U)) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.decode(AR_S)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.expandtabs(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.expandtabs(AR_S, tabsize=4)) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.join(AR_U, "_")) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.join(AR_S, [b"_", b""])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.ljust(AR_U, 5)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.rjust(AR_U, 5)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.lstrip(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.lstrip(AR_S, chars=b"_")) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.rstrip(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.rstrip(AR_S, chars=b"_")) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.strip(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.strip(AR_S, chars=b"_")) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.partition(AR_U, "\n")) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.partition(AR_S, [b"a", b"b", b"c"])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.rpartition(AR_U, "\n")) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.rpartition(AR_S, [b"a", b"b", b"c"])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.replace(AR_U, "_", "-")) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.replace(AR_S, [b"_", b""], [b"a", b"b"])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.split(AR_U, "_")) # E: ndarray[Any, dtype[object_]] reveal_type(np.char.split(AR_S, maxsplit=[1, 2, 3])) # E: ndarray[Any, dtype[object_]] reveal_type(np.char.rsplit(AR_U, "_")) # E: ndarray[Any, dtype[object_]] reveal_type(np.char.rsplit(AR_S, maxsplit=[1, 2, 3])) # E: ndarray[Any, dtype[object_]] reveal_type(np.char.splitlines(AR_U)) # E: ndarray[Any, dtype[object_]] reveal_type(np.char.splitlines(AR_S, keepends=[True, True, False])) # E: ndarray[Any, dtype[object_]] reveal_type(np.char.swapcase(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.swapcase(AR_S)) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.title(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.title(AR_S)) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.upper(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.upper(AR_S)) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.zfill(AR_U, 5)) # E: ndarray[Any, dtype[str_]] reveal_type(np.char.zfill(AR_S, [2, 3, 4])) # E: ndarray[Any, dtype[bytes_]] reveal_type(np.char.count(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.count(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.endswith(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.endswith(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.startswith(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.startswith(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.find(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.find(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.rfind(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.rfind(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.index(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.index(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.rindex(AR_U, "a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.rindex(AR_S, [b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.isalpha(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isalpha(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isalnum(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isalnum(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isdecimal(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isdecimal(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isdigit(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isdigit(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.islower(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.islower(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isnumeric(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isnumeric(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isspace(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isspace(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.istitle(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.istitle(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isupper(AR_U)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.isupper(AR_S)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.char.str_len(AR_U)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.str_len(AR_S)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.char.array(AR_U)) # E: chararray[Any, dtype[str_]] reveal_type(np.char.array(AR_S, order="K")) # E: chararray[Any, dtype[bytes_]] reveal_type(np.char.array("bob", copy=True)) # E: chararray[Any, dtype[str_]] reveal_type(np.char.array(b"bob", itemsize=5)) # E: chararray[Any, dtype[bytes_]] reveal_type(np.char.array(1, unicode=False)) # E: chararray[Any, dtype[bytes_]] reveal_type(np.char.array(1, unicode=True)) # E: chararray[Any, dtype[str_]] reveal_type(np.char.asarray(AR_U)) # E: chararray[Any, dtype[str_]] reveal_type(np.char.asarray(AR_S, order="K")) # E: chararray[Any, dtype[bytes_]] reveal_type(np.char.asarray("bob")) # E: chararray[Any, dtype[str_]] reveal_type(np.char.asarray(b"bob", itemsize=5)) # E: chararray[Any, dtype[bytes_]] reveal_type(np.char.asarray(1, unicode=False)) # E: chararray[Any, dtype[bytes_]] reveal_type(np.char.asarray(1, unicode=True)) # E: chararray[Any, dtype[str_]] PKIZ/6Edata/reveal/chararray.pyinu[import numpy as np from typing import Any AR_U: np.chararray[Any, np.dtype[np.str_]] AR_S: np.chararray[Any, np.dtype[np.bytes_]] reveal_type(AR_U == AR_U) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S == AR_S) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U != AR_U) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S != AR_S) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U >= AR_U) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S >= AR_S) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U <= AR_U) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S <= AR_S) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U > AR_U) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S > AR_S) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U < AR_U) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S < AR_S) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U * 5) # E: chararray[Any, dtype[str_]] reveal_type(AR_S * [5]) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U % "test") # E: chararray[Any, dtype[str_]] reveal_type(AR_S % b"test") # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.capitalize()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.capitalize()) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.center(5)) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.center([2, 3, 4], b"a")) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.encode()) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_S.decode()) # E: chararray[Any, dtype[str_]] reveal_type(AR_U.expandtabs()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.expandtabs(tabsize=4)) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.join("_")) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.join([b"_", b""])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.ljust(5)) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.ljust([4, 3, 1], fillchar=[b"a", b"b", b"c"])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.rjust(5)) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.rjust([4, 3, 1], fillchar=[b"a", b"b", b"c"])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.lstrip()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.lstrip(chars=b"_")) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.rstrip()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.rstrip(chars=b"_")) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.strip()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.strip(chars=b"_")) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.partition("\n")) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.partition([b"a", b"b", b"c"])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.rpartition("\n")) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.rpartition([b"a", b"b", b"c"])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.replace("_", "-")) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.replace([b"_", b""], [b"a", b"b"])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.split("_")) # E: ndarray[Any, dtype[object_]] reveal_type(AR_S.split(maxsplit=[1, 2, 3])) # E: ndarray[Any, dtype[object_]] reveal_type(AR_U.rsplit("_")) # E: ndarray[Any, dtype[object_]] reveal_type(AR_S.rsplit(maxsplit=[1, 2, 3])) # E: ndarray[Any, dtype[object_]] reveal_type(AR_U.splitlines()) # E: ndarray[Any, dtype[object_]] reveal_type(AR_S.splitlines(keepends=[True, True, False])) # E: ndarray[Any, dtype[object_]] reveal_type(AR_U.swapcase()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.swapcase()) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.title()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.title()) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.upper()) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.upper()) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.zfill(5)) # E: chararray[Any, dtype[str_]] reveal_type(AR_S.zfill([2, 3, 4])) # E: chararray[Any, dtype[bytes_]] reveal_type(AR_U.count("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_S.count([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_U.endswith("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.endswith([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.startswith("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.startswith([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.find("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_S.find([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_U.rfind("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_S.rfind([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_U.index("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_S.index([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_U.rindex("a", start=[1, 2, 3])) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_S.rindex([b"a", b"b", b"c"], end=9)) # E: ndarray[Any, dtype[{int_}]] reveal_type(AR_U.isalpha()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isalpha()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.isalnum()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isalnum()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.isdecimal()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isdecimal()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.isdigit()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isdigit()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.islower()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.islower()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.isnumeric()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isnumeric()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.isspace()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isspace()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.istitle()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.istitle()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.isupper()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_S.isupper()) # E: ndarray[Any, dtype[bool_]] reveal_type(AR_U.__array_finalize__(object())) # E: None reveal_type(AR_S.__array_finalize__(object())) # E: None PKIZX6RRdata/reveal/comparisons.pyinu[import numpy as np import fractions import decimal c16 = np.complex128() f8 = np.float64() i8 = np.int64() u8 = np.uint64() c8 = np.complex64() f4 = np.float32() i4 = np.int32() u4 = np.uint32() dt = np.datetime64(0, "D") td = np.timedelta64(0, "D") b_ = np.bool_() b = bool() c = complex() f = float() i = int() AR = np.array([0], dtype=np.int64) AR.setflags(write=False) SEQ = (0, 1, 2, 3, 4) # object-like comparisons reveal_type(i8 > fractions.Fraction(1, 5)) # E: Any reveal_type(i8 > [fractions.Fraction(1, 5)]) # E: Any reveal_type(i8 > decimal.Decimal("1.5")) # E: Any reveal_type(i8 > [decimal.Decimal("1.5")]) # E: Any # Time structures reveal_type(dt > dt) # E: bool_ reveal_type(td > td) # E: bool_ reveal_type(td > i) # E: bool_ reveal_type(td > i4) # E: bool_ reveal_type(td > i8) # E: bool_ reveal_type(td > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(td > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(AR > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(AR > td) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > td) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > AR) # E: ndarray[Any, dtype[bool_]] # boolean reveal_type(b_ > b) # E: bool_ reveal_type(b_ > b_) # E: bool_ reveal_type(b_ > i) # E: bool_ reveal_type(b_ > i8) # E: bool_ reveal_type(b_ > i4) # E: bool_ reveal_type(b_ > u8) # E: bool_ reveal_type(b_ > u4) # E: bool_ reveal_type(b_ > f) # E: bool_ reveal_type(b_ > f8) # E: bool_ reveal_type(b_ > f4) # E: bool_ reveal_type(b_ > c) # E: bool_ reveal_type(b_ > c16) # E: bool_ reveal_type(b_ > c8) # E: bool_ reveal_type(b_ > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(b_ > SEQ) # E: ndarray[Any, dtype[bool_]] # Complex reveal_type(c16 > c16) # E: bool_ reveal_type(c16 > f8) # E: bool_ reveal_type(c16 > i8) # E: bool_ reveal_type(c16 > c8) # E: bool_ reveal_type(c16 > f4) # E: bool_ reveal_type(c16 > i4) # E: bool_ reveal_type(c16 > b_) # E: bool_ reveal_type(c16 > b) # E: bool_ reveal_type(c16 > c) # E: bool_ reveal_type(c16 > f) # E: bool_ reveal_type(c16 > i) # E: bool_ reveal_type(c16 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(c16 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(c16 > c16) # E: bool_ reveal_type(f8 > c16) # E: bool_ reveal_type(i8 > c16) # E: bool_ reveal_type(c8 > c16) # E: bool_ reveal_type(f4 > c16) # E: bool_ reveal_type(i4 > c16) # E: bool_ reveal_type(b_ > c16) # E: bool_ reveal_type(b > c16) # E: bool_ reveal_type(c > c16) # E: bool_ reveal_type(f > c16) # E: bool_ reveal_type(i > c16) # E: bool_ reveal_type(AR > c16) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > c16) # E: ndarray[Any, dtype[bool_]] reveal_type(c8 > c16) # E: bool_ reveal_type(c8 > f8) # E: bool_ reveal_type(c8 > i8) # E: bool_ reveal_type(c8 > c8) # E: bool_ reveal_type(c8 > f4) # E: bool_ reveal_type(c8 > i4) # E: bool_ reveal_type(c8 > b_) # E: bool_ reveal_type(c8 > b) # E: bool_ reveal_type(c8 > c) # E: bool_ reveal_type(c8 > f) # E: bool_ reveal_type(c8 > i) # E: bool_ reveal_type(c8 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(c8 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(c16 > c8) # E: bool_ reveal_type(f8 > c8) # E: bool_ reveal_type(i8 > c8) # E: bool_ reveal_type(c8 > c8) # E: bool_ reveal_type(f4 > c8) # E: bool_ reveal_type(i4 > c8) # E: bool_ reveal_type(b_ > c8) # E: bool_ reveal_type(b > c8) # E: bool_ reveal_type(c > c8) # E: bool_ reveal_type(f > c8) # E: bool_ reveal_type(i > c8) # E: bool_ reveal_type(AR > c8) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > c8) # E: ndarray[Any, dtype[bool_]] # Float reveal_type(f8 > f8) # E: bool_ reveal_type(f8 > i8) # E: bool_ reveal_type(f8 > f4) # E: bool_ reveal_type(f8 > i4) # E: bool_ reveal_type(f8 > b_) # E: bool_ reveal_type(f8 > b) # E: bool_ reveal_type(f8 > c) # E: bool_ reveal_type(f8 > f) # E: bool_ reveal_type(f8 > i) # E: bool_ reveal_type(f8 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(f8 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(f8 > f8) # E: bool_ reveal_type(i8 > f8) # E: bool_ reveal_type(f4 > f8) # E: bool_ reveal_type(i4 > f8) # E: bool_ reveal_type(b_ > f8) # E: bool_ reveal_type(b > f8) # E: bool_ reveal_type(c > f8) # E: bool_ reveal_type(f > f8) # E: bool_ reveal_type(i > f8) # E: bool_ reveal_type(AR > f8) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > f8) # E: ndarray[Any, dtype[bool_]] reveal_type(f4 > f8) # E: bool_ reveal_type(f4 > i8) # E: bool_ reveal_type(f4 > f4) # E: bool_ reveal_type(f4 > i4) # E: bool_ reveal_type(f4 > b_) # E: bool_ reveal_type(f4 > b) # E: bool_ reveal_type(f4 > c) # E: bool_ reveal_type(f4 > f) # E: bool_ reveal_type(f4 > i) # E: bool_ reveal_type(f4 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(f4 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(f8 > f4) # E: bool_ reveal_type(i8 > f4) # E: bool_ reveal_type(f4 > f4) # E: bool_ reveal_type(i4 > f4) # E: bool_ reveal_type(b_ > f4) # E: bool_ reveal_type(b > f4) # E: bool_ reveal_type(c > f4) # E: bool_ reveal_type(f > f4) # E: bool_ reveal_type(i > f4) # E: bool_ reveal_type(AR > f4) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > f4) # E: ndarray[Any, dtype[bool_]] # Int reveal_type(i8 > i8) # E: bool_ reveal_type(i8 > u8) # E: bool_ reveal_type(i8 > i4) # E: bool_ reveal_type(i8 > u4) # E: bool_ reveal_type(i8 > b_) # E: bool_ reveal_type(i8 > b) # E: bool_ reveal_type(i8 > c) # E: bool_ reveal_type(i8 > f) # E: bool_ reveal_type(i8 > i) # E: bool_ reveal_type(i8 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(i8 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(u8 > u8) # E: bool_ reveal_type(u8 > i4) # E: bool_ reveal_type(u8 > u4) # E: bool_ reveal_type(u8 > b_) # E: bool_ reveal_type(u8 > b) # E: bool_ reveal_type(u8 > c) # E: bool_ reveal_type(u8 > f) # E: bool_ reveal_type(u8 > i) # E: bool_ reveal_type(u8 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(u8 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(i8 > i8) # E: bool_ reveal_type(u8 > i8) # E: bool_ reveal_type(i4 > i8) # E: bool_ reveal_type(u4 > i8) # E: bool_ reveal_type(b_ > i8) # E: bool_ reveal_type(b > i8) # E: bool_ reveal_type(c > i8) # E: bool_ reveal_type(f > i8) # E: bool_ reveal_type(i > i8) # E: bool_ reveal_type(AR > i8) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > i8) # E: ndarray[Any, dtype[bool_]] reveal_type(u8 > u8) # E: bool_ reveal_type(i4 > u8) # E: bool_ reveal_type(u4 > u8) # E: bool_ reveal_type(b_ > u8) # E: bool_ reveal_type(b > u8) # E: bool_ reveal_type(c > u8) # E: bool_ reveal_type(f > u8) # E: bool_ reveal_type(i > u8) # E: bool_ reveal_type(AR > u8) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > u8) # E: ndarray[Any, dtype[bool_]] reveal_type(i4 > i8) # E: bool_ reveal_type(i4 > i4) # E: bool_ reveal_type(i4 > i) # E: bool_ reveal_type(i4 > b_) # E: bool_ reveal_type(i4 > b) # E: bool_ reveal_type(i4 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(i4 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(u4 > i8) # E: bool_ reveal_type(u4 > i4) # E: bool_ reveal_type(u4 > u8) # E: bool_ reveal_type(u4 > u4) # E: bool_ reveal_type(u4 > i) # E: bool_ reveal_type(u4 > b_) # E: bool_ reveal_type(u4 > b) # E: bool_ reveal_type(u4 > AR) # E: ndarray[Any, dtype[bool_]] reveal_type(u4 > SEQ) # E: ndarray[Any, dtype[bool_]] reveal_type(i8 > i4) # E: bool_ reveal_type(i4 > i4) # E: bool_ reveal_type(i > i4) # E: bool_ reveal_type(b_ > i4) # E: bool_ reveal_type(b > i4) # E: bool_ reveal_type(AR > i4) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > i4) # E: ndarray[Any, dtype[bool_]] reveal_type(i8 > u4) # E: bool_ reveal_type(i4 > u4) # E: bool_ reveal_type(u8 > u4) # E: bool_ reveal_type(u4 > u4) # E: bool_ reveal_type(b_ > u4) # E: bool_ reveal_type(b > u4) # E: bool_ reveal_type(i > u4) # E: bool_ reveal_type(AR > u4) # E: ndarray[Any, dtype[bool_]] reveal_type(SEQ > u4) # E: ndarray[Any, dtype[bool_]] PKIZHX data/reveal/constants.pyinu[import numpy as np reveal_type(np.Inf) # E: float reveal_type(np.Infinity) # E: float reveal_type(np.NAN) # E: float reveal_type(np.NINF) # E: float reveal_type(np.NZERO) # E: float reveal_type(np.NaN) # E: float reveal_type(np.PINF) # E: float reveal_type(np.PZERO) # E: float reveal_type(np.e) # E: float reveal_type(np.euler_gamma) # E: float reveal_type(np.inf) # E: float reveal_type(np.infty) # E: float reveal_type(np.nan) # E: float reveal_type(np.pi) # E: float reveal_type(np.ALLOW_THREADS) # E: int reveal_type(np.BUFSIZE) # E: Literal[8192] reveal_type(np.CLIP) # E: Literal[0] reveal_type(np.ERR_CALL) # E: Literal[3] reveal_type(np.ERR_DEFAULT) # E: Literal[521] reveal_type(np.ERR_IGNORE) # E: Literal[0] reveal_type(np.ERR_LOG) # E: Literal[5] reveal_type(np.ERR_PRINT) # E: Literal[4] reveal_type(np.ERR_RAISE) # E: Literal[2] reveal_type(np.ERR_WARN) # E: Literal[1] reveal_type(np.FLOATING_POINT_SUPPORT) # E: Literal[1] reveal_type(np.FPE_DIVIDEBYZERO) # E: Literal[1] reveal_type(np.FPE_INVALID) # E: Literal[8] reveal_type(np.FPE_OVERFLOW) # E: Literal[2] reveal_type(np.FPE_UNDERFLOW) # E: Literal[4] reveal_type(np.MAXDIMS) # E: Literal[32] reveal_type(np.MAY_SHARE_BOUNDS) # E: Literal[0] reveal_type(np.MAY_SHARE_EXACT) # E: Literal[-1] reveal_type(np.RAISE) # E: Literal[2] reveal_type(np.SHIFT_DIVIDEBYZERO) # E: Literal[0] reveal_type(np.SHIFT_INVALID) # E: Literal[9] reveal_type(np.SHIFT_OVERFLOW) # E: Literal[3] reveal_type(np.SHIFT_UNDERFLOW) # E: Literal[6] reveal_type(np.UFUNC_BUFSIZE_DEFAULT) # E: Literal[8192] reveal_type(np.WRAP) # E: Literal[1] reveal_type(np.tracemalloc_domain) # E: Literal[389047] reveal_type(np.little_endian) # E: bool reveal_type(np.True_) # E: bool_ reveal_type(np.False_) # E: bool_ reveal_type(np.UFUNC_PYVALS_NAME) # E: Literal['UFUNC_PYVALS'] reveal_type(np.sctypeDict) # E: dict reveal_type(np.sctypes) # E: TypedDict PKIZ]data/reveal/ctypeslib.pyinu[import ctypes from typing import Any import numpy as np import numpy.typing as npt AR_bool: npt.NDArray[np.bool_] AR_ubyte: npt.NDArray[np.ubyte] AR_ushort: npt.NDArray[np.ushort] AR_uintc: npt.NDArray[np.uintc] AR_uint: npt.NDArray[np.uint] AR_ulonglong: npt.NDArray[np.ulonglong] AR_byte: npt.NDArray[np.byte] AR_short: npt.NDArray[np.short] AR_intc: npt.NDArray[np.intc] AR_int: npt.NDArray[np.int_] AR_longlong: npt.NDArray[np.longlong] AR_single: npt.NDArray[np.single] AR_double: npt.NDArray[np.double] AR_longdouble: npt.NDArray[np.longdouble] AR_void: npt.NDArray[np.void] pointer: ctypes._Pointer[Any] reveal_type(np.ctypeslib.c_intp()) # E: {c_intp} reveal_type(np.ctypeslib.ndpointer()) # E: Type[ctypeslib._ndptr[None]] reveal_type(np.ctypeslib.ndpointer(dtype=np.float64)) # E: Type[ctypeslib._ndptr[dtype[{float64}]]] reveal_type(np.ctypeslib.ndpointer(dtype=float)) # E: Type[ctypeslib._ndptr[dtype[Any]]] reveal_type(np.ctypeslib.ndpointer(shape=(10, 3))) # E: Type[ctypeslib._ndptr[None]] reveal_type(np.ctypeslib.ndpointer(np.int64, shape=(10, 3))) # E: Type[ctypeslib._concrete_ndptr[dtype[{int64}]]] reveal_type(np.ctypeslib.ndpointer(int, shape=(1,))) # E: Type[ctypeslib._concrete_ndptr[dtype[Any]]] reveal_type(np.ctypeslib.as_ctypes_type(np.bool_)) # E: Type[ctypes.c_bool] reveal_type(np.ctypeslib.as_ctypes_type(np.ubyte)) # E: Type[{c_ubyte}] reveal_type(np.ctypeslib.as_ctypes_type(np.ushort)) # E: Type[{c_ushort}] reveal_type(np.ctypeslib.as_ctypes_type(np.uintc)) # E: Type[{c_uint}] reveal_type(np.ctypeslib.as_ctypes_type(np.uint)) # E: Type[{c_ulong}] reveal_type(np.ctypeslib.as_ctypes_type(np.ulonglong)) # E: Type[{c_ulonglong}] reveal_type(np.ctypeslib.as_ctypes_type(np.byte)) # E: Type[{c_byte}] reveal_type(np.ctypeslib.as_ctypes_type(np.short)) # E: Type[{c_short}] reveal_type(np.ctypeslib.as_ctypes_type(np.intc)) # E: Type[{c_int}] reveal_type(np.ctypeslib.as_ctypes_type(np.int_)) # E: Type[{c_long}] reveal_type(np.ctypeslib.as_ctypes_type(np.longlong)) # E: Type[{c_longlong}] reveal_type(np.ctypeslib.as_ctypes_type(np.single)) # E: Type[{c_float}] reveal_type(np.ctypeslib.as_ctypes_type(np.double)) # E: Type[{c_double}] reveal_type(np.ctypeslib.as_ctypes_type(np.longdouble)) # E: Type[{c_longdouble}] reveal_type(np.ctypeslib.as_ctypes_type(ctypes.c_double)) # E: Type[{c_double}] reveal_type(np.ctypeslib.as_ctypes_type("q")) # E: Type[ctypes.c_longlong] reveal_type(np.ctypeslib.as_ctypes_type([("i8", np.int64), ("f8", np.float64)])) # E: Type[Any] reveal_type(np.ctypeslib.as_ctypes_type("i8")) # E: Type[Any] reveal_type(np.ctypeslib.as_ctypes_type("f8")) # E: Type[Any] reveal_type(np.ctypeslib.as_ctypes(AR_bool.take(0))) # E: ctypes.c_bool reveal_type(np.ctypeslib.as_ctypes(AR_ubyte.take(0))) # E: {c_ubyte} reveal_type(np.ctypeslib.as_ctypes(AR_ushort.take(0))) # E: {c_ushort} reveal_type(np.ctypeslib.as_ctypes(AR_uintc.take(0))) # E: {c_uint} reveal_type(np.ctypeslib.as_ctypes(AR_uint.take(0))) # E: {c_ulong} reveal_type(np.ctypeslib.as_ctypes(AR_ulonglong.take(0))) # E: {c_ulonglong} reveal_type(np.ctypeslib.as_ctypes(AR_byte.take(0))) # E: {c_byte} reveal_type(np.ctypeslib.as_ctypes(AR_short.take(0))) # E: {c_short} reveal_type(np.ctypeslib.as_ctypes(AR_intc.take(0))) # E: {c_int} reveal_type(np.ctypeslib.as_ctypes(AR_int.take(0))) # E: {c_long} reveal_type(np.ctypeslib.as_ctypes(AR_longlong.take(0))) # E: {c_longlong} reveal_type(np.ctypeslib.as_ctypes(AR_single.take(0))) # E: {c_float} reveal_type(np.ctypeslib.as_ctypes(AR_double.take(0))) # E: {c_double} reveal_type(np.ctypeslib.as_ctypes(AR_longdouble.take(0))) # E: {c_longdouble} reveal_type(np.ctypeslib.as_ctypes(AR_void.take(0))) # E: Any reveal_type(np.ctypeslib.as_ctypes(AR_bool)) # E: ctypes.Array[ctypes.c_bool] reveal_type(np.ctypeslib.as_ctypes(AR_ubyte)) # E: ctypes.Array[{c_ubyte}] reveal_type(np.ctypeslib.as_ctypes(AR_ushort)) # E: ctypes.Array[{c_ushort}] reveal_type(np.ctypeslib.as_ctypes(AR_uintc)) # E: ctypes.Array[{c_uint}] reveal_type(np.ctypeslib.as_ctypes(AR_uint)) # E: ctypes.Array[{c_ulong}] reveal_type(np.ctypeslib.as_ctypes(AR_ulonglong)) # E: ctypes.Array[{c_ulonglong}] reveal_type(np.ctypeslib.as_ctypes(AR_byte)) # E: ctypes.Array[{c_byte}] reveal_type(np.ctypeslib.as_ctypes(AR_short)) # E: ctypes.Array[{c_short}] reveal_type(np.ctypeslib.as_ctypes(AR_intc)) # E: ctypes.Array[{c_int}] reveal_type(np.ctypeslib.as_ctypes(AR_int)) # E: ctypes.Array[{c_long}] reveal_type(np.ctypeslib.as_ctypes(AR_longlong)) # E: ctypes.Array[{c_longlong}] reveal_type(np.ctypeslib.as_ctypes(AR_single)) # E: ctypes.Array[{c_float}] reveal_type(np.ctypeslib.as_ctypes(AR_double)) # E: ctypes.Array[{c_double}] reveal_type(np.ctypeslib.as_ctypes(AR_longdouble)) # E: ctypes.Array[{c_longdouble}] reveal_type(np.ctypeslib.as_ctypes(AR_void)) # E: ctypes.Array[Any] reveal_type(np.ctypeslib.as_array(AR_ubyte)) # E: ndarray[Any, dtype[{ubyte}]] reveal_type(np.ctypeslib.as_array(1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.ctypeslib.as_array(pointer)) # E: ndarray[Any, dtype[Any]] PKIZ:--data/reveal/datasource.pyinu[from pathlib import Path import numpy as np path1: Path path2: str d1 = np.DataSource(path1) d2 = np.DataSource(path2) d3 = np.DataSource(None) reveal_type(d1.abspath("...")) # E: str reveal_type(d2.abspath("...")) # E: str reveal_type(d3.abspath("...")) # E: str reveal_type(d1.exists("...")) # E: bool reveal_type(d2.exists("...")) # E: bool reveal_type(d3.exists("...")) # E: bool reveal_type(d1.open("...", "r")) # E: IO[Any] reveal_type(d2.open("...", encoding="utf8")) # E: IO[Any] reveal_type(d3.open("...", newline="/n")) # E: IO[Any] PKIZR data/reveal/dtype.pyinu[import ctypes as ct import numpy as np dtype_U: np.dtype[np.str_] dtype_V: np.dtype[np.void] dtype_i8: np.dtype[np.int64] reveal_type(np.dtype(np.float64)) # E: dtype[{float64}] reveal_type(np.dtype(np.float64, metadata={"test": "test"})) # E: dtype[{float64}] reveal_type(np.dtype(np.int64)) # E: dtype[{int64}] # String aliases reveal_type(np.dtype("float64")) # E: dtype[{float64}] reveal_type(np.dtype("float32")) # E: dtype[{float32}] reveal_type(np.dtype("int64")) # E: dtype[{int64}] reveal_type(np.dtype("int32")) # E: dtype[{int32}] reveal_type(np.dtype("bool")) # E: dtype[bool_] reveal_type(np.dtype("bytes")) # E: dtype[bytes_] reveal_type(np.dtype("str")) # E: dtype[str_] # Python types reveal_type(np.dtype(complex)) # E: dtype[{cdouble}] reveal_type(np.dtype(float)) # E: dtype[{double}] reveal_type(np.dtype(int)) # E: dtype[{int_}] reveal_type(np.dtype(bool)) # E: dtype[bool_] reveal_type(np.dtype(str)) # E: dtype[str_] reveal_type(np.dtype(bytes)) # E: dtype[bytes_] reveal_type(np.dtype(object)) # E: dtype[object_] # ctypes reveal_type(np.dtype(ct.c_double)) # E: dtype[{double}] reveal_type(np.dtype(ct.c_longlong)) # E: dtype[{longlong}] reveal_type(np.dtype(ct.c_uint32)) # E: dtype[{uint32}] reveal_type(np.dtype(ct.c_bool)) # E: dtype[bool_] reveal_type(np.dtype(ct.c_char)) # E: dtype[bytes_] reveal_type(np.dtype(ct.py_object)) # E: dtype[object_] # Special case for None reveal_type(np.dtype(None)) # E: dtype[{double}] # Dtypes of dtypes reveal_type(np.dtype(np.dtype(np.float64))) # E: dtype[{float64}] # Parameterized dtypes reveal_type(np.dtype("S8")) # E: dtype # Void reveal_type(np.dtype(("U", 10))) # E: dtype[void] # Methods and attributes reveal_type(dtype_U.base) # E: dtype[Any] reveal_type(dtype_U.subdtype) # E: Union[None, Tuple[dtype[Any], builtins.tuple[builtins.int, ...]]] reveal_type(dtype_U.newbyteorder()) # E: dtype[str_] reveal_type(dtype_U.type) # E: Type[str_] reveal_type(dtype_U.name) # E: str reveal_type(dtype_U.names) # E: Union[None, builtins.tuple[builtins.str, ...]] reveal_type(dtype_U * 0) # E: dtype[str_] reveal_type(dtype_U * 1) # E: dtype[str_] reveal_type(dtype_U * 2) # E: dtype[str_] reveal_type(dtype_i8 * 0) # E: dtype[void] reveal_type(dtype_i8 * 1) # E: dtype[{int64}] reveal_type(dtype_i8 * 2) # E: dtype[void] reveal_type(0 * dtype_U) # E: dtype[str_] reveal_type(1 * dtype_U) # E: dtype[str_] reveal_type(2 * dtype_U) # E: dtype[str_] reveal_type(0 * dtype_i8) # E: dtype[Any] reveal_type(1 * dtype_i8) # E: dtype[Any] reveal_type(2 * dtype_i8) # E: dtype[Any] reveal_type(dtype_V["f0"]) # E: dtype[Any] reveal_type(dtype_V[0]) # E: dtype[Any] reveal_type(dtype_V[["f0", "f1"]]) # E: dtype[void] reveal_type(dtype_V[["f0"]]) # E: dtype[void] PKIZ*}}data/reveal/einsumfunc.pyinu[from typing import Any import numpy as np import numpy.typing as npt AR_LIKE_b: list[bool] AR_LIKE_u: list[np.uint32] AR_LIKE_i: list[int] AR_LIKE_f: list[float] AR_LIKE_c: list[complex] AR_LIKE_U: list[str] AR_o: npt.NDArray[np.object_] OUT_f: npt.NDArray[np.float64] reveal_type(np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_b)) # E: Any reveal_type(np.einsum("i,i->i", AR_o, AR_o)) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_u, AR_LIKE_u)) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_i, AR_LIKE_i)) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f)) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c)) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_i)) # E: Any reveal_type(np.einsum("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c)) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c, out=OUT_f)) # E: ndarray[Any, dtype[{float64}] reveal_type(np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe", out=OUT_f)) # E: ndarray[Any, dtype[{float64}] reveal_type(np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, dtype="c16")) # E: Any reveal_type(np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe")) # E: Any reveal_type(np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_b)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum_path("i,i->i", AR_LIKE_u, AR_LIKE_u)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum_path("i,i->i", AR_LIKE_i, AR_LIKE_i)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c)) # E: Tuple[builtins.list[Any], builtins.str] reveal_type(np.einsum([[1, 1], [1, 1]], AR_LIKE_i, AR_LIKE_i)) # E: Any reveal_type(np.einsum_path([[1, 1], [1, 1]], AR_LIKE_i, AR_LIKE_i)) # E: Tuple[builtins.list[Any], builtins.str] PKIZi˳ data/reveal/emath.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] f8: np.float64 c16: np.complex128 reveal_type(np.emath.sqrt(f8)) # E: Any reveal_type(np.emath.sqrt(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.sqrt(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.sqrt(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.log(f8)) # E: Any reveal_type(np.emath.log(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.log(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.log(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.log10(f8)) # E: Any reveal_type(np.emath.log10(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.log10(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.log10(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.log2(f8)) # E: Any reveal_type(np.emath.log2(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.log2(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.log2(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.logn(f8, 2)) # E: Any reveal_type(np.emath.logn(AR_f8, 4)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.logn(f8, 1j)) # E: complexfloating[Any, Any] reveal_type(np.emath.logn(AR_c16, 1.5)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.power(f8, 2)) # E: Any reveal_type(np.emath.power(AR_f8, 4)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.power(f8, 2j)) # E: complexfloating[Any, Any] reveal_type(np.emath.power(AR_c16, 1.5)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.arccos(f8)) # E: Any reveal_type(np.emath.arccos(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.arccos(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.arccos(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.arcsin(f8)) # E: Any reveal_type(np.emath.arcsin(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.arcsin(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.arcsin(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.emath.arctanh(f8)) # E: Any reveal_type(np.emath.arctanh(AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.emath.arctanh(c16)) # E: complexfloating[Any, Any] reveal_type(np.emath.arctanh(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] PKIZ ײ]]data/reveal/false_positives.pyinu[from typing import Any import numpy.typing as npt AR_Any: npt.NDArray[Any] # Mypy bug where overload ambiguity is ignored for `Any`-parametrized types; # xref numpy/numpy#20099 and python/mypy#11347 # # The expected output would be something akin to `ndarray[Any, dtype[Any]]` reveal_type(AR_Any + 2) # E: ndarray[Any, dtype[signedinteger[Any]]] PKIZz&~<<data/reveal/fft.pyinu[import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_LIKE_f8: list[float] reveal_type(np.fft.fftshift(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fft.fftshift(AR_LIKE_f8, axes=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.fft.ifftshift(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fft.ifftshift(AR_LIKE_f8, axes=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.fft.fftfreq(5, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.fft.fftfreq(np.int64(), AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.fft.fftfreq(5, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.fft.fftfreq(np.int64(), AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.fft.fft(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.ifft(AR_f8, axis=1)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.rfft(AR_f8, n=None)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.irfft(AR_f8, norm="ortho")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fft.hfft(AR_f8, n=2)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fft.ihfft(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.fftn(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.ifftn(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.rfftn(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.irfftn(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fft.rfft2(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.ifft2(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.fft2(AR_f8)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.fft.irfft2(AR_f8)) # E: ndarray[Any, dtype[{float64}]] PKIZ+u33data/reveal/flatiter.pyinu[from typing import Any import numpy as np a: np.flatiter[np.ndarray[Any, np.dtype[np.str_]]] reveal_type(a.base) # E: ndarray[Any, dtype[str_]] reveal_type(a.copy()) # E: ndarray[Any, dtype[str_]] reveal_type(a.coords) # E: tuple[builtins.int, ...] reveal_type(a.index) # E: int reveal_type(iter(a)) # E: Any reveal_type(next(a)) # E: str_ reveal_type(a[0]) # E: str_ reveal_type(a[[0, 1, 2]]) # E: ndarray[Any, dtype[str_]] reveal_type(a[...]) # E: ndarray[Any, dtype[str_]] reveal_type(a[:]) # E: ndarray[Any, dtype[str_]] reveal_type(a[(...,)]) # E: ndarray[Any, dtype[str_]] reveal_type(a[(0,)]) # E: str_ reveal_type(a.__array__()) # E: ndarray[Any, dtype[str_]] reveal_type(a.__array__(np.dtype(np.float64))) # E: ndarray[Any, dtype[{float64}]] a[0] = "a" a[:5] = "a" a[...] = "a" a[(...,)] = "a" PKIZj^?5?5data/reveal/fromnumeric.pyinu["""Tests for :mod:`core.fromnumeric`.""" import numpy as np import numpy.typing as npt class NDArraySubclass(npt.NDArray[np.complex128]): ... AR_b: npt.NDArray[np.bool_] AR_f4: npt.NDArray[np.float32] AR_c16: npt.NDArray[np.complex128] AR_u8: npt.NDArray[np.uint64] AR_i8: npt.NDArray[np.int64] AR_O: npt.NDArray[np.object_] AR_subclass: NDArraySubclass b: np.bool_ f4: np.float32 i8: np.int64 f: float reveal_type(np.take(b, 0)) # E: bool_ reveal_type(np.take(f4, 0)) # E: {float32} reveal_type(np.take(f, 0)) # E: Any reveal_type(np.take(AR_b, 0)) # E: bool_ reveal_type(np.take(AR_f4, 0)) # E: {float32} reveal_type(np.take(AR_b, [0])) # E: ndarray[Any, dtype[bool_]] reveal_type(np.take(AR_f4, [0])) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.take([1], [0])) # E: ndarray[Any, dtype[Any]] reveal_type(np.take(AR_f4, [0], out=AR_subclass)) # E: NDArraySubclass reveal_type(np.reshape(b, 1)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.reshape(f4, 1)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.reshape(f, 1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.reshape(AR_b, 1)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.reshape(AR_f4, 1)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.choose(1, [True, True])) # E: Any reveal_type(np.choose([1], [True, True])) # E: ndarray[Any, dtype[Any]] reveal_type(np.choose([1], AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.choose([1], AR_b, out=AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.repeat(b, 1)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.repeat(f4, 1)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.repeat(f, 1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.repeat(AR_b, 1)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.repeat(AR_f4, 1)) # E: ndarray[Any, dtype[{float32}]] # TODO: array_bdd tests for np.put() reveal_type(np.swapaxes([[0, 1]], 0, 0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.swapaxes(AR_b, 0, 0)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.swapaxes(AR_f4, 0, 0)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.transpose(b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.transpose(f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.transpose(f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.transpose(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.transpose(AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.partition(b, 0, axis=None)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.partition(f4, 0, axis=None)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.partition(f, 0, axis=None)) # E: ndarray[Any, dtype[Any]] reveal_type(np.partition(AR_b, 0)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.partition(AR_f4, 0)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.argpartition(b, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argpartition(f4, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argpartition(f, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argpartition(AR_b, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argpartition(AR_f4, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.sort([2, 1], 0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.sort(AR_b, 0)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.sort(AR_f4, 0)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.argsort(AR_b, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argsort(AR_f4, 0)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argmax(AR_b)) # E: {intp} reveal_type(np.argmax(AR_f4)) # E: {intp} reveal_type(np.argmax(AR_b, axis=0)) # E: Any reveal_type(np.argmax(AR_f4, axis=0)) # E: Any reveal_type(np.argmax(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.argmin(AR_b)) # E: {intp} reveal_type(np.argmin(AR_f4)) # E: {intp} reveal_type(np.argmin(AR_b, axis=0)) # E: Any reveal_type(np.argmin(AR_f4, axis=0)) # E: Any reveal_type(np.argmin(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.searchsorted(AR_b[0], 0)) # E: {intp} reveal_type(np.searchsorted(AR_f4[0], 0)) # E: {intp} reveal_type(np.searchsorted(AR_b[0], [0])) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.searchsorted(AR_f4[0], [0])) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.resize(b, (5, 5))) # E: ndarray[Any, dtype[bool_]] reveal_type(np.resize(f4, (5, 5))) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.resize(f, (5, 5))) # E: ndarray[Any, dtype[Any]] reveal_type(np.resize(AR_b, (5, 5))) # E: ndarray[Any, dtype[bool_]] reveal_type(np.resize(AR_f4, (5, 5))) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.squeeze(b)) # E: bool_ reveal_type(np.squeeze(f4)) # E: {float32} reveal_type(np.squeeze(f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.squeeze(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.squeeze(AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.diagonal(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.diagonal(AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.trace(AR_b)) # E: Any reveal_type(np.trace(AR_f4)) # E: Any reveal_type(np.trace(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.ravel(b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.ravel(f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.ravel(f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.ravel(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.ravel(AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.nonzero(b)) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.nonzero(f4)) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.nonzero(f)) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.nonzero(AR_b)) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.nonzero(AR_f4)) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.shape(b)) # E: tuple[builtins.int, ...] reveal_type(np.shape(f4)) # E: tuple[builtins.int, ...] reveal_type(np.shape(f)) # E: tuple[builtins.int, ...] reveal_type(np.shape(AR_b)) # E: tuple[builtins.int, ...] reveal_type(np.shape(AR_f4)) # E: tuple[builtins.int, ...] reveal_type(np.compress([True], b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.compress([True], f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.compress([True], f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.compress([True], AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.compress([True], AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.clip(b, 0, 1.0)) # E: bool_ reveal_type(np.clip(f4, -1, 1)) # E: {float32} reveal_type(np.clip(f, 0, 1)) # E: Any reveal_type(np.clip(AR_b, 0, 1)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.clip(AR_f4, 0, 1)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.clip([0], 0, 1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.clip(AR_b, 0, 1, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.sum(b)) # E: bool_ reveal_type(np.sum(f4)) # E: {float32} reveal_type(np.sum(f)) # E: Any reveal_type(np.sum(AR_b)) # E: bool_ reveal_type(np.sum(AR_f4)) # E: {float32} reveal_type(np.sum(AR_b, axis=0)) # E: Any reveal_type(np.sum(AR_f4, axis=0)) # E: Any reveal_type(np.sum(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.all(b)) # E: bool_ reveal_type(np.all(f4)) # E: bool_ reveal_type(np.all(f)) # E: bool_ reveal_type(np.all(AR_b)) # E: bool_ reveal_type(np.all(AR_f4)) # E: bool_ reveal_type(np.all(AR_b, axis=0)) # E: Any reveal_type(np.all(AR_f4, axis=0)) # E: Any reveal_type(np.all(AR_b, keepdims=True)) # E: Any reveal_type(np.all(AR_f4, keepdims=True)) # E: Any reveal_type(np.all(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.any(b)) # E: bool_ reveal_type(np.any(f4)) # E: bool_ reveal_type(np.any(f)) # E: bool_ reveal_type(np.any(AR_b)) # E: bool_ reveal_type(np.any(AR_f4)) # E: bool_ reveal_type(np.any(AR_b, axis=0)) # E: Any reveal_type(np.any(AR_f4, axis=0)) # E: Any reveal_type(np.any(AR_b, keepdims=True)) # E: Any reveal_type(np.any(AR_f4, keepdims=True)) # E: Any reveal_type(np.any(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.cumsum(b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.cumsum(f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.cumsum(f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.cumsum(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.cumsum(AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.cumsum(f, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.cumsum(f, dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.cumsum(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.ptp(b)) # E: bool_ reveal_type(np.ptp(f4)) # E: {float32} reveal_type(np.ptp(f)) # E: Any reveal_type(np.ptp(AR_b)) # E: bool_ reveal_type(np.ptp(AR_f4)) # E: {float32} reveal_type(np.ptp(AR_b, axis=0)) # E: Any reveal_type(np.ptp(AR_f4, axis=0)) # E: Any reveal_type(np.ptp(AR_b, keepdims=True)) # E: Any reveal_type(np.ptp(AR_f4, keepdims=True)) # E: Any reveal_type(np.ptp(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.amax(b)) # E: bool_ reveal_type(np.amax(f4)) # E: {float32} reveal_type(np.amax(f)) # E: Any reveal_type(np.amax(AR_b)) # E: bool_ reveal_type(np.amax(AR_f4)) # E: {float32} reveal_type(np.amax(AR_b, axis=0)) # E: Any reveal_type(np.amax(AR_f4, axis=0)) # E: Any reveal_type(np.amax(AR_b, keepdims=True)) # E: Any reveal_type(np.amax(AR_f4, keepdims=True)) # E: Any reveal_type(np.amax(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.amin(b)) # E: bool_ reveal_type(np.amin(f4)) # E: {float32} reveal_type(np.amin(f)) # E: Any reveal_type(np.amin(AR_b)) # E: bool_ reveal_type(np.amin(AR_f4)) # E: {float32} reveal_type(np.amin(AR_b, axis=0)) # E: Any reveal_type(np.amin(AR_f4, axis=0)) # E: Any reveal_type(np.amin(AR_b, keepdims=True)) # E: Any reveal_type(np.amin(AR_f4, keepdims=True)) # E: Any reveal_type(np.amin(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.prod(AR_b)) # E: {int_} reveal_type(np.prod(AR_u8)) # E: {uint64} reveal_type(np.prod(AR_i8)) # E: {int64} reveal_type(np.prod(AR_f4)) # E: floating[Any] reveal_type(np.prod(AR_c16)) # E: complexfloating[Any, Any] reveal_type(np.prod(AR_O)) # E: Any reveal_type(np.prod(AR_f4, axis=0)) # E: Any reveal_type(np.prod(AR_f4, keepdims=True)) # E: Any reveal_type(np.prod(AR_f4, dtype=np.float64)) # E: {float64} reveal_type(np.prod(AR_f4, dtype=float)) # E: Any reveal_type(np.prod(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.cumprod(AR_b)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.cumprod(AR_u8)) # E: ndarray[Any, dtype[{uint64}]] reveal_type(np.cumprod(AR_i8)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.cumprod(AR_f4)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.cumprod(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.cumprod(AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.cumprod(AR_f4, axis=0)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.cumprod(AR_f4, dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.cumprod(AR_f4, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.cumprod(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.ndim(b)) # E: int reveal_type(np.ndim(f4)) # E: int reveal_type(np.ndim(f)) # E: int reveal_type(np.ndim(AR_b)) # E: int reveal_type(np.ndim(AR_f4)) # E: int reveal_type(np.size(b)) # E: int reveal_type(np.size(f4)) # E: int reveal_type(np.size(f)) # E: int reveal_type(np.size(AR_b)) # E: int reveal_type(np.size(AR_f4)) # E: int reveal_type(np.around(b)) # E: {float16} reveal_type(np.around(f)) # E: Any reveal_type(np.around(i8)) # E: {int64} reveal_type(np.around(f4)) # E: {float32} reveal_type(np.around(AR_b)) # E: ndarray[Any, dtype[{float16}]] reveal_type(np.around(AR_i8)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.around(AR_f4)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.around([1.5])) # E: ndarray[Any, dtype[Any]] reveal_type(np.around(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.mean(AR_b)) # E: floating[Any] reveal_type(np.mean(AR_i8)) # E: floating[Any] reveal_type(np.mean(AR_f4)) # E: floating[Any] reveal_type(np.mean(AR_c16)) # E: complexfloating[Any, Any] reveal_type(np.mean(AR_O)) # E: Any reveal_type(np.mean(AR_f4, axis=0)) # E: Any reveal_type(np.mean(AR_f4, keepdims=True)) # E: Any reveal_type(np.mean(AR_f4, dtype=float)) # E: Any reveal_type(np.mean(AR_f4, dtype=np.float64)) # E: {float64} reveal_type(np.mean(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.std(AR_b)) # E: floating[Any] reveal_type(np.std(AR_i8)) # E: floating[Any] reveal_type(np.std(AR_f4)) # E: floating[Any] reveal_type(np.std(AR_c16)) # E: floating[Any] reveal_type(np.std(AR_O)) # E: Any reveal_type(np.std(AR_f4, axis=0)) # E: Any reveal_type(np.std(AR_f4, keepdims=True)) # E: Any reveal_type(np.std(AR_f4, dtype=float)) # E: Any reveal_type(np.std(AR_f4, dtype=np.float64)) # E: {float64} reveal_type(np.std(AR_f4, out=AR_subclass)) # E: NDArraySubclass reveal_type(np.var(AR_b)) # E: floating[Any] reveal_type(np.var(AR_i8)) # E: floating[Any] reveal_type(np.var(AR_f4)) # E: floating[Any] reveal_type(np.var(AR_c16)) # E: floating[Any] reveal_type(np.var(AR_O)) # E: Any reveal_type(np.var(AR_f4, axis=0)) # E: Any reveal_type(np.var(AR_f4, keepdims=True)) # E: Any reveal_type(np.var(AR_f4, dtype=float)) # E: Any reveal_type(np.var(AR_f4, dtype=np.float64)) # E: {float64} reveal_type(np.var(AR_f4, out=AR_subclass)) # E: NDArraySubclass PKIZSK  data/reveal/getlimits.pyinu[import numpy as np f: float f8: np.float64 c8: np.complex64 i: int i8: np.int64 u4: np.uint32 finfo_f8: np.finfo[np.float64] iinfo_i8: np.iinfo[np.int64] reveal_type(np.finfo(f)) # E: finfo[{double}] reveal_type(np.finfo(f8)) # E: finfo[{float64}] reveal_type(np.finfo(c8)) # E: finfo[{float32}] reveal_type(np.finfo('f2')) # E: finfo[floating[Any]] reveal_type(finfo_f8.dtype) # E: dtype[{float64}] reveal_type(finfo_f8.bits) # E: int reveal_type(finfo_f8.eps) # E: {float64} reveal_type(finfo_f8.epsneg) # E: {float64} reveal_type(finfo_f8.iexp) # E: int reveal_type(finfo_f8.machep) # E: int reveal_type(finfo_f8.max) # E: {float64} reveal_type(finfo_f8.maxexp) # E: int reveal_type(finfo_f8.min) # E: {float64} reveal_type(finfo_f8.minexp) # E: int reveal_type(finfo_f8.negep) # E: int reveal_type(finfo_f8.nexp) # E: int reveal_type(finfo_f8.nmant) # E: int reveal_type(finfo_f8.precision) # E: int reveal_type(finfo_f8.resolution) # E: {float64} reveal_type(finfo_f8.tiny) # E: {float64} reveal_type(finfo_f8.smallest_normal) # E: {float64} reveal_type(finfo_f8.smallest_subnormal) # E: {float64} reveal_type(np.iinfo(i)) # E: iinfo[{int_}] reveal_type(np.iinfo(i8)) # E: iinfo[{int64}] reveal_type(np.iinfo(u4)) # E: iinfo[{uint32}] reveal_type(np.iinfo('i2')) # E: iinfo[Any] reveal_type(iinfo_i8.dtype) # E: dtype[{int64}] reveal_type(iinfo_i8.kind) # E: str reveal_type(iinfo_i8.bits) # E: int reveal_type(iinfo_i8.key) # E: str reveal_type(iinfo_i8.min) # E: int reveal_type(iinfo_i8.max) # E: int PKIZOoodata/reveal/histograms.pyinu[import numpy as np import numpy.typing as npt AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] reveal_type(np.histogram_bin_edges(AR_i8, bins="auto")) # E: ndarray[Any, dtype[Any]] reveal_type(np.histogram_bin_edges(AR_i8, bins="rice", range=(0, 3))) # E: ndarray[Any, dtype[Any]] reveal_type(np.histogram_bin_edges(AR_i8, bins="scott", weights=AR_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.histogram(AR_i8, bins="auto")) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] reveal_type(np.histogram(AR_i8, bins="rice", range=(0, 3))) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] reveal_type(np.histogram(AR_i8, bins="scott", weights=AR_f8)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] reveal_type(np.histogram(AR_f8, bins=1, density=True)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] reveal_type(np.histogramdd(AR_i8, bins=[1])) # E: Tuple[ndarray[Any, dtype[Any]], builtins.list[ndarray[Any, dtype[Any]]]] reveal_type(np.histogramdd(AR_i8, range=[(0, 3)])) # E: Tuple[ndarray[Any, dtype[Any]], builtins.list[ndarray[Any, dtype[Any]]]] reveal_type(np.histogramdd(AR_i8, weights=AR_f8)) # E: Tuple[ndarray[Any, dtype[Any]], builtins.list[ndarray[Any, dtype[Any]]]] reveal_type(np.histogramdd(AR_f8, density=True)) # E: Tuple[ndarray[Any, dtype[Any]], builtins.list[ndarray[Any, dtype[Any]]]] PKIZ%h data/reveal/index_tricks.pyinu[from typing import Any import numpy as np AR_LIKE_b: list[bool] AR_LIKE_i: list[int] AR_LIKE_f: list[float] AR_LIKE_U: list[str] AR_i8: np.ndarray[Any, np.dtype[np.int64]] reveal_type(np.ndenumerate(AR_i8)) # E: ndenumerate[{int64}] reveal_type(np.ndenumerate(AR_LIKE_f)) # E: ndenumerate[{double}] reveal_type(np.ndenumerate(AR_LIKE_U)) # E: ndenumerate[str_] reveal_type(np.ndenumerate(AR_i8).iter) # E: flatiter[ndarray[Any, dtype[{int64}]]] reveal_type(np.ndenumerate(AR_LIKE_f).iter) # E: flatiter[ndarray[Any, dtype[{double}]]] reveal_type(np.ndenumerate(AR_LIKE_U).iter) # E: flatiter[ndarray[Any, dtype[str_]]] reveal_type(next(np.ndenumerate(AR_i8))) # E: Tuple[builtins.tuple[builtins.int, ...], {int64}] reveal_type(next(np.ndenumerate(AR_LIKE_f))) # E: Tuple[builtins.tuple[builtins.int, ...], {double}] reveal_type(next(np.ndenumerate(AR_LIKE_U))) # E: Tuple[builtins.tuple[builtins.int, ...], str_] reveal_type(iter(np.ndenumerate(AR_i8))) # E: ndenumerate[{int64}] reveal_type(iter(np.ndenumerate(AR_LIKE_f))) # E: ndenumerate[{double}] reveal_type(iter(np.ndenumerate(AR_LIKE_U))) # E: ndenumerate[str_] reveal_type(np.ndindex(1, 2, 3)) # E: numpy.ndindex reveal_type(np.ndindex((1, 2, 3))) # E: numpy.ndindex reveal_type(iter(np.ndindex(1, 2, 3))) # E: ndindex reveal_type(next(np.ndindex(1, 2, 3))) # E: builtins.tuple[builtins.int, ...] reveal_type(np.unravel_index([22, 41, 37], (7, 6))) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.unravel_index([31, 41, 13], (7, 6), order="F")) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.unravel_index(1621, (6, 7, 8, 9))) # E: tuple[{intp}, ...] reveal_type(np.ravel_multi_index([[1]], (7, 6))) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.ravel_multi_index(AR_LIKE_i, (7, 6))) # E: {intp} reveal_type(np.ravel_multi_index(AR_LIKE_i, (7, 6), order="F")) # E: {intp} reveal_type(np.ravel_multi_index(AR_LIKE_i, (4, 6), mode="clip")) # E: {intp} reveal_type(np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=("clip", "wrap"))) # E: {intp} reveal_type(np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9))) # E: {intp} reveal_type(np.mgrid[1:1:2]) # E: ndarray[Any, dtype[Any]] reveal_type(np.mgrid[1:1:2, None:10]) # E: ndarray[Any, dtype[Any]] reveal_type(np.ogrid[1:1:2]) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.ogrid[1:1:2, None:10]) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.index_exp[0:1]) # E: Tuple[builtins.slice] reveal_type(np.index_exp[0:1, None:3]) # E: Tuple[builtins.slice, builtins.slice] reveal_type(np.index_exp[0, 0:1, ..., [0, 1, 3]]) # E: Tuple[Literal[0]?, builtins.slice, builtins.ellipsis, builtins.list[builtins.int]] reveal_type(np.s_[0:1]) # E: builtins.slice reveal_type(np.s_[0:1, None:3]) # E: Tuple[builtins.slice, builtins.slice] reveal_type(np.s_[0, 0:1, ..., [0, 1, 3]]) # E: Tuple[Literal[0]?, builtins.slice, builtins.ellipsis, builtins.list[builtins.int]] reveal_type(np.ix_(AR_LIKE_b)) # E: tuple[ndarray[Any, dtype[bool_]], ...] reveal_type(np.ix_(AR_LIKE_i, AR_LIKE_f)) # E: tuple[ndarray[Any, dtype[{double}]], ...] reveal_type(np.ix_(AR_i8)) # E: tuple[ndarray[Any, dtype[{int64}]], ...] reveal_type(np.fill_diagonal(AR_i8, 5)) # E: None reveal_type(np.diag_indices(4)) # E: tuple[ndarray[Any, dtype[{int_}]], ...] reveal_type(np.diag_indices(2, 3)) # E: tuple[ndarray[Any, dtype[{int_}]], ...] reveal_type(np.diag_indices_from(AR_i8)) # E: tuple[ndarray[Any, dtype[{int_}]], ...] PKIZn,e##!data/reveal/lib_function_base.pyinu[from typing import Any import numpy as np import numpy.typing as npt vectorized_func: np.vectorize f8: np.float64 AR_LIKE_f8: list[float] AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_m: npt.NDArray[np.timedelta64] AR_M: npt.NDArray[np.datetime64] AR_O: npt.NDArray[np.object_] AR_b: npt.NDArray[np.bool_] AR_U: npt.NDArray[np.str_] CHAR_AR_U: np.chararray[Any, np.dtype[np.str_]] def func(*args: Any, **kwargs: Any) -> Any: ... reveal_type(vectorized_func.pyfunc) # E: def (*Any, **Any) -> Any reveal_type(vectorized_func.cache) # E: bool reveal_type(vectorized_func.signature) # E: Union[None, builtins.str] reveal_type(vectorized_func.otypes) # E: Union[None, builtins.str] reveal_type(vectorized_func.excluded) # E: set[Union[builtins.int, builtins.str]] reveal_type(vectorized_func.__doc__) # E: Union[None, builtins.str] reveal_type(vectorized_func([1])) # E: Any reveal_type(np.vectorize(int)) # E: vectorize reveal_type(np.vectorize( # E: vectorize int, otypes="i", doc="doc", excluded=(), cache=True, signature=None )) reveal_type(np.add_newdoc("__main__", "blabla", doc="test doc")) # E: None reveal_type(np.add_newdoc("__main__", "blabla", doc=("meth", "test doc"))) # E: None reveal_type(np.add_newdoc("__main__", "blabla", doc=[("meth", "test doc")])) # E: None reveal_type(np.rot90(AR_f8, k=2)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.rot90(AR_LIKE_f8, axes=(0, 1))) # E: ndarray[Any, dtype[Any]] reveal_type(np.flip(f8)) # E: {float64} reveal_type(np.flip(1.0)) # E: Any reveal_type(np.flip(AR_f8, axis=(0, 1))) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.flip(AR_LIKE_f8, axis=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.iterable(1)) # E: bool reveal_type(np.iterable([1])) # E: bool reveal_type(np.average(AR_f8)) # E: floating[Any] reveal_type(np.average(AR_f8, weights=AR_c16)) # E: complexfloating[Any, Any] reveal_type(np.average(AR_O)) # E: Any reveal_type(np.average(AR_f8, returned=True)) # E: Tuple[floating[Any], floating[Any]] reveal_type(np.average(AR_f8, weights=AR_c16, returned=True)) # E: Tuple[complexfloating[Any, Any], complexfloating[Any, Any]] reveal_type(np.average(AR_O, returned=True)) # E: Tuple[Any, Any] reveal_type(np.average(AR_f8, axis=0)) # E: Any reveal_type(np.average(AR_f8, axis=0, returned=True)) # E: Tuple[Any, Any] reveal_type(np.asarray_chkfinite(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asarray_chkfinite(AR_LIKE_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.asarray_chkfinite(AR_f8, dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asarray_chkfinite(AR_f8, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.piecewise(AR_f8, AR_b, [func])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.piecewise(AR_LIKE_f8, AR_b, [func])) # E: ndarray[Any, dtype[Any]] reveal_type(np.select([AR_f8], [AR_f8])) # E: ndarray[Any, dtype[Any]] reveal_type(np.copy(AR_LIKE_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.copy(AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.copy(CHAR_AR_U)) # E: ndarray[Any, Any] reveal_type(np.copy(CHAR_AR_U, "K", subok=True)) # E: chararray[Any, dtype[str_]] reveal_type(np.copy(CHAR_AR_U, subok=True)) # E: chararray[Any, dtype[str_]] reveal_type(np.gradient(AR_f8, axis=None)) # E: Any reveal_type(np.gradient(AR_LIKE_f8, edge_order=2)) # E: Any reveal_type(np.diff("bob", n=0)) # E: str reveal_type(np.diff(AR_f8, axis=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.diff(AR_LIKE_f8, prepend=1.5)) # E: ndarray[Any, dtype[Any]] reveal_type(np.angle(f8)) # E: floating[Any] reveal_type(np.angle(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.angle(AR_c16, deg=True)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.angle(AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.unwrap(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.unwrap(AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.sort_complex(AR_f8)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.trim_zeros(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.trim_zeros(AR_LIKE_f8)) # E: list[builtins.float] reveal_type(np.extract(AR_i8, AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.extract(AR_i8, AR_LIKE_f8)) # E: ndarray[Any, dtype[Any]] reveal_type(np.place(AR_f8, mask=AR_i8, vals=5.0)) # E: None reveal_type(np.disp(1, linefeed=True)) # E: None with open("test", "w") as f: reveal_type(np.disp("message", device=f)) # E: None reveal_type(np.cov(AR_f8, bias=True)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.cov(AR_f8, AR_c16, ddof=1)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.cov(AR_f8, aweights=AR_f8, dtype=np.float32)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.cov(AR_f8, fweights=AR_f8, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.corrcoef(AR_f8, rowvar=True)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.corrcoef(AR_f8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.corrcoef(AR_f8, dtype=np.float32)) # E: ndarray[Any, dtype[{float32}]] reveal_type(np.corrcoef(AR_f8, dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.blackman(5)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.bartlett(6)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.hanning(4.5)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.hamming(0)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.i0(AR_i8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.kaiser(4, 5.9)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.sinc(1.0)) # E: floating[Any] reveal_type(np.sinc(1j)) # E: complexfloating[Any, Any] reveal_type(np.sinc(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.sinc(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.median(AR_f8, keepdims=False)) # E: floating[Any] reveal_type(np.median(AR_c16, overwrite_input=True)) # E: complexfloating[Any, Any] reveal_type(np.median(AR_m)) # E: timedelta64 reveal_type(np.median(AR_O)) # E: Any reveal_type(np.median(AR_f8, keepdims=True)) # E: Any reveal_type(np.median(AR_c16, axis=0)) # E: Any reveal_type(np.median(AR_LIKE_f8, out=AR_c16)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.add_newdoc_ufunc(np.add, "docstring")) # E: None reveal_type(np.percentile(AR_f8, 50)) # E: floating[Any] reveal_type(np.percentile(AR_c16, 50)) # E: complexfloating[Any, Any] reveal_type(np.percentile(AR_m, 50)) # E: timedelta64 reveal_type(np.percentile(AR_M, 50, overwrite_input=True)) # E: datetime64 reveal_type(np.percentile(AR_O, 50)) # E: Any reveal_type(np.percentile(AR_f8, [50])) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.percentile(AR_c16, [50])) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.percentile(AR_m, [50])) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.percentile(AR_M, [50], method="nearest")) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.percentile(AR_O, [50])) # E: ndarray[Any, dtype[object_]] reveal_type(np.percentile(AR_f8, [50], keepdims=True)) # E: Any reveal_type(np.percentile(AR_f8, [50], axis=[1])) # E: Any reveal_type(np.percentile(AR_f8, [50], out=AR_c16)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.quantile(AR_f8, 0.5)) # E: floating[Any] reveal_type(np.quantile(AR_c16, 0.5)) # E: complexfloating[Any, Any] reveal_type(np.quantile(AR_m, 0.5)) # E: timedelta64 reveal_type(np.quantile(AR_M, 0.5, overwrite_input=True)) # E: datetime64 reveal_type(np.quantile(AR_O, 0.5)) # E: Any reveal_type(np.quantile(AR_f8, [0.5])) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.quantile(AR_c16, [0.5])) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.quantile(AR_m, [0.5])) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.quantile(AR_M, [0.5], method="nearest")) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.quantile(AR_O, [0.5])) # E: ndarray[Any, dtype[object_]] reveal_type(np.quantile(AR_f8, [0.5], keepdims=True)) # E: Any reveal_type(np.quantile(AR_f8, [0.5], axis=[1])) # E: Any reveal_type(np.quantile(AR_f8, [0.5], out=AR_c16)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.meshgrid(AR_f8, AR_i8, copy=False)) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.meshgrid(AR_f8, AR_i8, AR_c16, indexing="ij")) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.delete(AR_f8, np.s_[:5])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.delete(AR_LIKE_f8, [0, 4, 9], axis=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.insert(AR_f8, np.s_[:5], 5)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.insert(AR_LIKE_f8, [0, 4, 9], [0.5, 9.2, 7], axis=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.append(AR_f8, 5)) # E: ndarray[Any, dtype[Any]] reveal_type(np.append(AR_LIKE_f8, 1j, axis=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.digitize(4.5, [1])) # E: {intp} reveal_type(np.digitize(AR_f8, [1, 2, 3])) # E: ndarray[Any, dtype[{intp}]] PKIZjdata/reveal/lib_polynomial.pyinu[import numpy as np import numpy.typing as npt AR_b: npt.NDArray[np.bool_] AR_u4: npt.NDArray[np.uint32] AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_O: npt.NDArray[np.object_] poly_obj: np.poly1d reveal_type(poly_obj.variable) # E: str reveal_type(poly_obj.order) # E: int reveal_type(poly_obj.o) # E: int reveal_type(poly_obj.roots) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj.r) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj.coeffs) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj.c) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj.coef) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj.coefficients) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj.__hash__) # E: None reveal_type(poly_obj(1)) # E: Any reveal_type(poly_obj([1])) # E: ndarray[Any, dtype[Any]] reveal_type(poly_obj(poly_obj)) # E: poly1d reveal_type(len(poly_obj)) # E: int reveal_type(-poly_obj) # E: poly1d reveal_type(+poly_obj) # E: poly1d reveal_type(poly_obj * 5) # E: poly1d reveal_type(5 * poly_obj) # E: poly1d reveal_type(poly_obj + 5) # E: poly1d reveal_type(5 + poly_obj) # E: poly1d reveal_type(poly_obj - 5) # E: poly1d reveal_type(5 - poly_obj) # E: poly1d reveal_type(poly_obj**1) # E: poly1d reveal_type(poly_obj**1.0) # E: poly1d reveal_type(poly_obj / 5) # E: poly1d reveal_type(5 / poly_obj) # E: poly1d reveal_type(poly_obj[0]) # E: Any poly_obj[0] = 5 reveal_type(iter(poly_obj)) # E: Iterator[Any] reveal_type(poly_obj.deriv()) # E: poly1d reveal_type(poly_obj.integ()) # E: poly1d reveal_type(np.poly(poly_obj)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.poly(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.poly(AR_c16)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polyint(poly_obj)) # E: poly1d reveal_type(np.polyint(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polyint(AR_f8, k=AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.polyint(AR_O, m=2)) # E: ndarray[Any, dtype[object_]] reveal_type(np.polyder(poly_obj)) # E: poly1d reveal_type(np.polyder(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polyder(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.polyder(AR_O, m=2)) # E: ndarray[Any, dtype[object_]] reveal_type(np.polyfit(AR_f8, AR_f8, 2)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.polyfit(AR_f8, AR_i8, 1, full=True)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[signedinteger[typing._32Bit]]], ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{float64}]]] reveal_type(np.polyfit(AR_u4, AR_f8, 1.0, cov="unscaled")) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{float64}]]] reveal_type(np.polyfit(AR_c16, AR_f8, 2)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(np.polyfit(AR_f8, AR_c16, 1, full=True)) # E: Tuple[ndarray[Any, dtype[{complex128}]], ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[signedinteger[typing._32Bit]]], ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{float64}]]] reveal_type(np.polyfit(AR_u4, AR_c16, 1.0, cov=True)) # E: Tuple[ndarray[Any, dtype[{complex128}]], ndarray[Any, dtype[{complex128}]]] reveal_type(np.polyval(AR_b, AR_b)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.polyval(AR_u4, AR_b)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.polyval(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.polyval(AR_f8, AR_i8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polyval(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.polyval(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.polyadd(poly_obj, AR_i8)) # E: poly1d reveal_type(np.polyadd(AR_f8, poly_obj)) # E: poly1d reveal_type(np.polyadd(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.polyadd(AR_u4, AR_b)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.polyadd(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.polyadd(AR_f8, AR_i8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polyadd(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.polyadd(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.polysub(poly_obj, AR_i8)) # E: poly1d reveal_type(np.polysub(AR_f8, poly_obj)) # E: poly1d reveal_type(np.polysub(AR_b, AR_b)) # E: reveal_type(np.polysub(AR_u4, AR_b)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.polysub(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.polysub(AR_f8, AR_i8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polysub(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.polysub(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.polymul(poly_obj, AR_i8)) # E: poly1d reveal_type(np.polymul(AR_f8, poly_obj)) # E: poly1d reveal_type(np.polymul(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.polymul(AR_u4, AR_b)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.polymul(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.polymul(AR_f8, AR_i8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.polymul(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.polymul(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.polydiv(poly_obj, AR_i8)) # E: poly1d reveal_type(np.polydiv(AR_f8, poly_obj)) # E: poly1d reveal_type(np.polydiv(AR_b, AR_b)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(np.polydiv(AR_u4, AR_b)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(np.polydiv(AR_i8, AR_i8)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(np.polydiv(AR_f8, AR_i8)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(np.polydiv(AR_i8, AR_c16)) # E: Tuple[ndarray[Any, dtype[complexfloating[Any, Any]]], ndarray[Any, dtype[complexfloating[Any, Any]]]] reveal_type(np.polydiv(AR_O, AR_O)) # E: Tuple[ndarray[Any, dtype[Any]], ndarray[Any, dtype[Any]]] PKIZdata/reveal/lib_utils.pyinu[from io import StringIO from typing import Any import numpy as np AR: np.ndarray[Any, np.dtype[np.float64]] AR_DICT: dict[str, np.ndarray[Any, np.dtype[np.float64]]] FILE: StringIO def func(a: int) -> bool: ... reveal_type(np.deprecate(func)) # E: def (a: builtins.int) -> builtins.bool reveal_type(np.deprecate()) # E: _Deprecate reveal_type(np.deprecate_with_doc("test")) # E: _Deprecate reveal_type(np.deprecate_with_doc(None)) # E: _Deprecate reveal_type(np.byte_bounds(AR)) # E: Tuple[builtins.int, builtins.int] reveal_type(np.byte_bounds(np.float64())) # E: Tuple[builtins.int, builtins.int] reveal_type(np.who(None)) # E: None reveal_type(np.who(AR_DICT)) # E: None reveal_type(np.info(1, output=FILE)) # E: None reveal_type(np.source(np.interp, output=FILE)) # E: None reveal_type(np.lookfor("binary representation", output=FILE)) # E: None reveal_type(np.safe_eval("1 + 1")) # E: Any PKIZ5]]data/reveal/lib_version.pyinu[from numpy.lib import NumpyVersion version = NumpyVersion("1.8.0") reveal_type(version.vstring) # E: str reveal_type(version.version) # E: str reveal_type(version.major) # E: int reveal_type(version.minor) # E: int reveal_type(version.bugfix) # E: int reveal_type(version.pre_release) # E: str reveal_type(version.is_devversion) # E: bool reveal_type(version == version) # E: bool reveal_type(version != version) # E: bool reveal_type(version < "1.8.0") # E: bool reveal_type(version <= version) # E: bool reveal_type(version > version) # E: bool reveal_type(version >= "1.8.0") # E: bool PKIZ˴zaadata/reveal/linalg.pyinu[import numpy as np import numpy.typing as npt AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_O: npt.NDArray[np.object_] AR_m: npt.NDArray[np.timedelta64] AR_S: npt.NDArray[np.str_] reveal_type(np.linalg.tensorsolve(AR_i8, AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.tensorsolve(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.tensorsolve(AR_c16, AR_f8)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.solve(AR_i8, AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.solve(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.solve(AR_c16, AR_f8)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.tensorinv(AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.tensorinv(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.tensorinv(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.inv(AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.inv(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.inv(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.matrix_power(AR_i8, -1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.linalg.matrix_power(AR_f8, 0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.linalg.matrix_power(AR_c16, 1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.linalg.matrix_power(AR_O, 2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.linalg.cholesky(AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.cholesky(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.cholesky(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.qr(AR_i8)) # E: QRResult reveal_type(np.linalg.qr(AR_f8)) # E: QRResult reveal_type(np.linalg.qr(AR_c16)) # E: QRResult reveal_type(np.linalg.eigvals(AR_i8)) # E: Union[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{complex128}]]] reveal_type(np.linalg.eigvals(AR_f8)) # E: Union[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[complexfloating[Any, Any]]]] reveal_type(np.linalg.eigvals(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.eigvalsh(AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.eigvalsh(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.eigvalsh(AR_c16)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.eig(AR_i8)) # E: EigResult reveal_type(np.linalg.eig(AR_f8)) # E: EigResult reveal_type(np.linalg.eig(AR_c16)) # E: EigResult reveal_type(np.linalg.eigh(AR_i8)) # E: EighResult reveal_type(np.linalg.eigh(AR_f8)) # E: EighResult reveal_type(np.linalg.eigh(AR_c16)) # E: EighResult reveal_type(np.linalg.svd(AR_i8)) # E: SVDResult reveal_type(np.linalg.svd(AR_f8)) # E: SVDResult reveal_type(np.linalg.svd(AR_c16)) # E: SVDResult reveal_type(np.linalg.svd(AR_i8, compute_uv=False)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.svd(AR_f8, compute_uv=False)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.svd(AR_c16, compute_uv=False)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.cond(AR_i8)) # E: Any reveal_type(np.linalg.cond(AR_f8)) # E: Any reveal_type(np.linalg.cond(AR_c16)) # E: Any reveal_type(np.linalg.matrix_rank(AR_i8)) # E: Any reveal_type(np.linalg.matrix_rank(AR_f8)) # E: Any reveal_type(np.linalg.matrix_rank(AR_c16)) # E: Any reveal_type(np.linalg.pinv(AR_i8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.linalg.pinv(AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.linalg.pinv(AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.linalg.slogdet(AR_i8)) # E: SlogdetResult reveal_type(np.linalg.slogdet(AR_f8)) # E: SlogdetResult reveal_type(np.linalg.slogdet(AR_c16)) # E: SlogdetResult reveal_type(np.linalg.det(AR_i8)) # E: Any reveal_type(np.linalg.det(AR_f8)) # E: Any reveal_type(np.linalg.det(AR_c16)) # E: Any reveal_type(np.linalg.lstsq(AR_i8, AR_i8)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{float64}]], {int32}, ndarray[Any, dtype[{float64}]]] reveal_type(np.linalg.lstsq(AR_i8, AR_f8)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]], {int32}, ndarray[Any, dtype[floating[Any]]]] reveal_type(np.linalg.lstsq(AR_f8, AR_c16)) # E: Tuple[ndarray[Any, dtype[complexfloating[Any, Any]]], ndarray[Any, dtype[floating[Any]]], {int32}, ndarray[Any, dtype[floating[Any]]]] reveal_type(np.linalg.norm(AR_i8)) # E: floating[Any] reveal_type(np.linalg.norm(AR_f8)) # E: floating[Any] reveal_type(np.linalg.norm(AR_c16)) # E: floating[Any] reveal_type(np.linalg.norm(AR_S)) # E: floating[Any] reveal_type(np.linalg.norm(AR_f8, axis=0)) # E: Any reveal_type(np.linalg.multi_dot([AR_i8, AR_i8])) # E: Any reveal_type(np.linalg.multi_dot([AR_i8, AR_f8])) # E: Any reveal_type(np.linalg.multi_dot([AR_f8, AR_c16])) # E: Any reveal_type(np.linalg.multi_dot([AR_O, AR_O])) # E: Any reveal_type(np.linalg.multi_dot([AR_m, AR_m])) # E: Any PKIZâ5 data/reveal/matrix.pyinu[from typing import Any import numpy as np import numpy.typing as npt mat: np.matrix[Any, np.dtype[np.int64]] ar_f8: npt.NDArray[np.float64] reveal_type(mat * 5) # E: matrix[Any, Any] reveal_type(5 * mat) # E: matrix[Any, Any] mat *= 5 reveal_type(mat**5) # E: matrix[Any, Any] mat **= 5 reveal_type(mat.sum()) # E: Any reveal_type(mat.mean()) # E: Any reveal_type(mat.std()) # E: Any reveal_type(mat.var()) # E: Any reveal_type(mat.prod()) # E: Any reveal_type(mat.any()) # E: bool_ reveal_type(mat.all()) # E: bool_ reveal_type(mat.max()) # E: {int64} reveal_type(mat.min()) # E: {int64} reveal_type(mat.argmax()) # E: {intp} reveal_type(mat.argmin()) # E: {intp} reveal_type(mat.ptp()) # E: {int64} reveal_type(mat.sum(axis=0)) # E: matrix[Any, Any] reveal_type(mat.mean(axis=0)) # E: matrix[Any, Any] reveal_type(mat.std(axis=0)) # E: matrix[Any, Any] reveal_type(mat.var(axis=0)) # E: matrix[Any, Any] reveal_type(mat.prod(axis=0)) # E: matrix[Any, Any] reveal_type(mat.any(axis=0)) # E: matrix[Any, dtype[bool_]] reveal_type(mat.all(axis=0)) # E: matrix[Any, dtype[bool_]] reveal_type(mat.max(axis=0)) # E: matrix[Any, dtype[{int64}]] reveal_type(mat.min(axis=0)) # E: matrix[Any, dtype[{int64}]] reveal_type(mat.argmax(axis=0)) # E: matrix[Any, dtype[{intp}]] reveal_type(mat.argmin(axis=0)) # E: matrix[Any, dtype[{intp}]] reveal_type(mat.ptp(axis=0)) # E: matrix[Any, dtype[{int64}]] reveal_type(mat.sum(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.mean(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.std(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.var(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.prod(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.any(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.all(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.max(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.min(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.argmax(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.argmin(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.ptp(out=ar_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(mat.T) # E: matrix[Any, dtype[{int64}]] reveal_type(mat.I) # E: matrix[Any, Any] reveal_type(mat.A) # E: ndarray[Any, dtype[{int64}]] reveal_type(mat.A1) # E: ndarray[Any, dtype[{int64}]] reveal_type(mat.H) # E: matrix[Any, dtype[{int64}]] reveal_type(mat.getT()) # E: matrix[Any, dtype[{int64}]] reveal_type(mat.getI()) # E: matrix[Any, Any] reveal_type(mat.getA()) # E: ndarray[Any, dtype[{int64}]] reveal_type(mat.getA1()) # E: ndarray[Any, dtype[{int64}]] reveal_type(mat.getH()) # E: matrix[Any, dtype[{int64}]] reveal_type(np.bmat(ar_f8)) # E: matrix[Any, Any] reveal_type(np.bmat([[0, 1, 2]])) # E: matrix[Any, Any] reveal_type(np.bmat("mat")) # E: matrix[Any, Any] reveal_type(np.asmatrix(ar_f8, dtype=np.int64)) # E: matrix[Any, Any] PKIZx/data/reveal/memmap.pyinu[import numpy as np from typing import Any memmap_obj: np.memmap[Any, np.dtype[np.str_]] reveal_type(np.memmap.__array_priority__) # E: float reveal_type(memmap_obj.__array_priority__) # E: float reveal_type(memmap_obj.filename) # E: Union[builtins.str, None] reveal_type(memmap_obj.offset) # E: int reveal_type(memmap_obj.mode) # E: str reveal_type(memmap_obj.flush()) # E: None reveal_type(np.memmap("file.txt", offset=5)) # E: memmap[Any, dtype[{uint8}]] reveal_type(np.memmap(b"file.txt", dtype=np.float64, shape=(10, 3))) # E: memmap[Any, dtype[{float64}]] with open("file.txt", "rb") as f: reveal_type(np.memmap(f, dtype=float, order="K")) # E: memmap[Any, dtype[Any]] reveal_type(memmap_obj.__array_finalize__(object())) # E: None PKIZo7eedata/reveal/mod.pyinu[from typing import Any import numpy as np f8 = np.float64() i8 = np.int64() u8 = np.uint64() f4 = np.float32() i4 = np.int32() u4 = np.uint32() td = np.timedelta64(0, "D") b_ = np.bool_() b = bool() f = float() i = int() AR_b: np.ndarray[Any, np.dtype[np.bool_]] AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] # Time structures reveal_type(td % td) # E: timedelta64 reveal_type(AR_m % td) # E: Any reveal_type(td % AR_m) # E: Any reveal_type(divmod(td, td)) # E: Tuple[{int64}, timedelta64] reveal_type(divmod(AR_m, td)) # E: Tuple[ndarray[Any, dtype[signedinteger[typing._64Bit]]], ndarray[Any, dtype[timedelta64]]] reveal_type(divmod(td, AR_m)) # E: Tuple[ndarray[Any, dtype[signedinteger[typing._64Bit]]], ndarray[Any, dtype[timedelta64]]] # Bool reveal_type(b_ % b) # E: {int8} reveal_type(b_ % i) # E: {int_} reveal_type(b_ % f) # E: {float64} reveal_type(b_ % b_) # E: {int8} reveal_type(b_ % i8) # E: {int64} reveal_type(b_ % u8) # E: {uint64} reveal_type(b_ % f8) # E: {float64} reveal_type(b_ % AR_b) # E: ndarray[Any, dtype[{int8}]] reveal_type(divmod(b_, b)) # E: Tuple[{int8}, {int8}] reveal_type(divmod(b_, i)) # E: Tuple[{int_}, {int_}] reveal_type(divmod(b_, f)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(b_, b_)) # E: Tuple[{int8}, {int8}] reveal_type(divmod(b_, i8)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(b_, u8)) # E: Tuple[{uint64}, {uint64}] reveal_type(divmod(b_, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(b_, AR_b)) # E: ndarray[Any, dtype[{int8}]], ndarray[Any, dtype[{int8}]]] reveal_type(b % b_) # E: {int8} reveal_type(i % b_) # E: {int_} reveal_type(f % b_) # E: {float64} reveal_type(b_ % b_) # E: {int8} reveal_type(i8 % b_) # E: {int64} reveal_type(u8 % b_) # E: {uint64} reveal_type(f8 % b_) # E: {float64} reveal_type(AR_b % b_) # E: ndarray[Any, dtype[{int8}]] reveal_type(divmod(b, b_)) # E: Tuple[{int8}, {int8}] reveal_type(divmod(i, b_)) # E: Tuple[{int_}, {int_}] reveal_type(divmod(f, b_)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(b_, b_)) # E: Tuple[{int8}, {int8}] reveal_type(divmod(i8, b_)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(u8, b_)) # E: Tuple[{uint64}, {uint64}] reveal_type(divmod(f8, b_)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(AR_b, b_)) # E: ndarray[Any, dtype[{int8}]], ndarray[Any, dtype[{int8}]]] # int reveal_type(i8 % b) # E: {int64} reveal_type(i8 % i) # E: {int64} reveal_type(i8 % f) # E: {float64} reveal_type(i8 % i8) # E: {int64} reveal_type(i8 % f8) # E: {float64} reveal_type(i4 % i8) # E: {int64} reveal_type(i4 % f8) # E: {float64} reveal_type(i4 % i4) # E: {int32} reveal_type(i4 % f4) # E: {float32} reveal_type(i8 % AR_b) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(divmod(i8, b)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(i8, i)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(i8, f)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i8, i8)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(i8, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i8, i4)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(i8, f4)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i4, i4)) # E: Tuple[{int32}, {int32}] reveal_type(divmod(i4, f4)) # E: Tuple[{float32}, {float32}] reveal_type(divmod(i8, AR_b)) # E: Tuple[ndarray[Any, dtype[signedinteger[Any]]], ndarray[Any, dtype[signedinteger[Any]]]] reveal_type(b % i8) # E: {int64} reveal_type(i % i8) # E: {int64} reveal_type(f % i8) # E: {float64} reveal_type(i8 % i8) # E: {int64} reveal_type(f8 % i8) # E: {float64} reveal_type(i8 % i4) # E: {int64} reveal_type(f8 % i4) # E: {float64} reveal_type(i4 % i4) # E: {int32} reveal_type(f4 % i4) # E: {float32} reveal_type(AR_b % i8) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(divmod(b, i8)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(i, i8)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(f, i8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i8, i8)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(f8, i8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i4, i8)) # E: Tuple[{int64}, {int64}] reveal_type(divmod(f4, i8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i4, i4)) # E: Tuple[{int32}, {int32}] reveal_type(divmod(f4, i4)) # E: Tuple[{float32}, {float32}] reveal_type(divmod(AR_b, i8)) # E: Tuple[ndarray[Any, dtype[signedinteger[Any]]], ndarray[Any, dtype[signedinteger[Any]]]] # float reveal_type(f8 % b) # E: {float64} reveal_type(f8 % i) # E: {float64} reveal_type(f8 % f) # E: {float64} reveal_type(i8 % f4) # E: {float64} reveal_type(f4 % f4) # E: {float32} reveal_type(f8 % AR_b) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(divmod(f8, b)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f8, i)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f8, f)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f8, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f8, f4)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f4, f4)) # E: Tuple[{float32}, {float32}] reveal_type(divmod(f8, AR_b)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(b % f8) # E: {float64} reveal_type(i % f8) # E: {float64} reveal_type(f % f8) # E: {float64} reveal_type(f8 % f8) # E: {float64} reveal_type(f8 % f8) # E: {float64} reveal_type(f4 % f4) # E: {float32} reveal_type(AR_b % f8) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(divmod(b, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(i, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f8, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f4, f8)) # E: Tuple[{float64}, {float64}] reveal_type(divmod(f4, f4)) # E: Tuple[{float32}, {float32}] reveal_type(divmod(AR_b, f8)) # E: Tuple[ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] PKIZ=Ydata/reveal/modules.pyinu[import numpy as np from numpy import f2py reveal_type(np) # E: ModuleType reveal_type(np.char) # E: ModuleType reveal_type(np.ctypeslib) # E: ModuleType reveal_type(np.emath) # E: ModuleType reveal_type(np.fft) # E: ModuleType reveal_type(np.lib) # E: ModuleType reveal_type(np.linalg) # E: ModuleType reveal_type(np.ma) # E: ModuleType reveal_type(np.matrixlib) # E: ModuleType reveal_type(np.polynomial) # E: ModuleType reveal_type(np.random) # E: ModuleType reveal_type(np.rec) # E: ModuleType reveal_type(np.testing) # E: ModuleType reveal_type(np.version) # E: ModuleType reveal_type(np.exceptions) # E: ModuleType reveal_type(np.dtypes) # E: ModuleType reveal_type(np.lib.format) # E: ModuleType reveal_type(np.lib.mixins) # E: ModuleType reveal_type(np.lib.scimath) # E: ModuleType reveal_type(np.lib.stride_tricks) # E: ModuleType reveal_type(np.ma.extras) # E: ModuleType reveal_type(np.polynomial.chebyshev) # E: ModuleType reveal_type(np.polynomial.hermite) # E: ModuleType reveal_type(np.polynomial.hermite_e) # E: ModuleType reveal_type(np.polynomial.laguerre) # E: ModuleType reveal_type(np.polynomial.legendre) # E: ModuleType reveal_type(np.polynomial.polynomial) # E: ModuleType reveal_type(np.__path__) # E: list[builtins.str] reveal_type(np.__version__) # E: str reveal_type(np.__git_version__) # E: str reveal_type(np.test) # E: _pytesttester.PytestTester reveal_type(np.test.module_name) # E: str reveal_type(np.__all__) # E: list[builtins.str] reveal_type(np.char.__all__) # E: list[builtins.str] reveal_type(np.ctypeslib.__all__) # E: list[builtins.str] reveal_type(np.emath.__all__) # E: list[builtins.str] reveal_type(np.lib.__all__) # E: list[builtins.str] reveal_type(np.ma.__all__) # E: list[builtins.str] reveal_type(np.random.__all__) # E: list[builtins.str] reveal_type(np.rec.__all__) # E: list[builtins.str] reveal_type(np.testing.__all__) # E: list[builtins.str] reveal_type(f2py.__all__) # E: list[builtins.str] PKIZRB&&data/reveal/multiarray.pyinu[import datetime as dt from typing import Any, TypeVar from pathlib import Path import numpy as np import numpy.typing as npt _SCT = TypeVar("_SCT", bound=np.generic, covariant=True) class SubClass(np.ndarray[Any, np.dtype[_SCT]]): ... subclass: SubClass[np.float64] AR_f8: npt.NDArray[np.float64] AR_i8: npt.NDArray[np.int64] AR_u1: npt.NDArray[np.uint8] AR_m: npt.NDArray[np.timedelta64] AR_M: npt.NDArray[np.datetime64] AR_LIKE_f: list[float] AR_LIKE_i: list[int] m: np.timedelta64 M: np.datetime64 b_f8 = np.broadcast(AR_f8) b_i8_f8_f8 = np.broadcast(AR_i8, AR_f8, AR_f8) nditer_obj: np.nditer date_scalar: dt.date date_seq: list[dt.date] timedelta_seq: list[dt.timedelta] def func(a: int) -> bool: ... reveal_type(next(b_f8)) # E: tuple[Any, ...] reveal_type(b_f8.reset()) # E: None reveal_type(b_f8.index) # E: int reveal_type(b_f8.iters) # E: tuple[flatiter[Any], ...] reveal_type(b_f8.nd) # E: int reveal_type(b_f8.ndim) # E: int reveal_type(b_f8.numiter) # E: int reveal_type(b_f8.shape) # E: tuple[builtins.int, ...] reveal_type(b_f8.size) # E: int reveal_type(next(b_i8_f8_f8)) # E: tuple[Any, ...] reveal_type(b_i8_f8_f8.reset()) # E: None reveal_type(b_i8_f8_f8.index) # E: int reveal_type(b_i8_f8_f8.iters) # E: tuple[flatiter[Any], ...] reveal_type(b_i8_f8_f8.nd) # E: int reveal_type(b_i8_f8_f8.ndim) # E: int reveal_type(b_i8_f8_f8.numiter) # E: int reveal_type(b_i8_f8_f8.shape) # E: tuple[builtins.int, ...] reveal_type(b_i8_f8_f8.size) # E: int reveal_type(np.inner(AR_f8, AR_i8)) # E: Any reveal_type(np.where([True, True, False])) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(np.where([True, True, False], 1, 0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.lexsort([0, 1, 2])) # E: Any reveal_type(np.can_cast(np.dtype("i8"), int)) # E: bool reveal_type(np.can_cast(AR_f8, "f8")) # E: bool reveal_type(np.can_cast(AR_f8, np.complex128, casting="unsafe")) # E: bool reveal_type(np.min_scalar_type([1])) # E: dtype[Any] reveal_type(np.min_scalar_type(AR_f8)) # E: dtype[Any] reveal_type(np.result_type(int, [1])) # E: dtype[Any] reveal_type(np.result_type(AR_f8, AR_u1)) # E: dtype[Any] reveal_type(np.result_type(AR_f8, np.complex128)) # E: dtype[Any] reveal_type(np.dot(AR_LIKE_f, AR_i8)) # E: Any reveal_type(np.dot(AR_u1, 1)) # E: Any reveal_type(np.dot(1.5j, 1)) # E: Any reveal_type(np.dot(AR_u1, 1, out=AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.vdot(AR_LIKE_f, AR_i8)) # E: floating[Any] reveal_type(np.vdot(AR_u1, 1)) # E: signedinteger[Any] reveal_type(np.vdot(1.5j, 1)) # E: complexfloating[Any, Any] reveal_type(np.bincount(AR_i8)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.copyto(AR_f8, [1., 1.5, 1.6])) # E: None reveal_type(np.putmask(AR_f8, [True, True, False], 1.5)) # E: None reveal_type(np.packbits(AR_i8)) # ndarray[Any, dtype[{uint8}]] reveal_type(np.packbits(AR_u1)) # ndarray[Any, dtype[{uint8}]] reveal_type(np.unpackbits(AR_u1)) # ndarray[Any, dtype[{uint8}]] reveal_type(np.shares_memory(1, 2)) # E: bool reveal_type(np.shares_memory(AR_f8, AR_f8, max_work=1)) # E: bool reveal_type(np.may_share_memory(1, 2)) # E: bool reveal_type(np.may_share_memory(AR_f8, AR_f8, max_work=1)) # E: bool reveal_type(np.geterrobj()) # E: list[Any] reveal_type(np.seterrobj([8192, 521, None])) # E: None reveal_type(np.promote_types(np.int32, np.int64)) # E: dtype[Any] reveal_type(np.promote_types("f4", float)) # E: dtype[Any] reveal_type(np.frompyfunc(func, 1, 1, identity=None)) # ufunc reveal_type(np.datetime_data("m8[D]")) # E: Tuple[builtins.str, builtins.int] reveal_type(np.datetime_data(np.datetime64)) # E: Tuple[builtins.str, builtins.int] reveal_type(np.datetime_data(np.dtype(np.timedelta64))) # E: Tuple[builtins.str, builtins.int] reveal_type(np.busday_count("2011-01", "2011-02")) # E: {int_} reveal_type(np.busday_count(["2011-01"], "2011-02")) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.busday_count(["2011-01"], date_scalar)) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.busday_offset(M, m)) # E: datetime64 reveal_type(np.busday_offset(date_scalar, m)) # E: datetime64 reveal_type(np.busday_offset(M, 5)) # E: datetime64 reveal_type(np.busday_offset(AR_M, m)) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.busday_offset(M, timedelta_seq)) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.busday_offset("2011-01", "2011-02", roll="forward")) # E: datetime64 reveal_type(np.busday_offset(["2011-01"], "2011-02", roll="forward")) # E: ndarray[Any, dtype[datetime64]] reveal_type(np.is_busday("2012")) # E: bool_ reveal_type(np.is_busday(date_scalar)) # E: bool_ reveal_type(np.is_busday(["2012"])) # E: ndarray[Any, dtype[bool_]] reveal_type(np.datetime_as_string(M)) # E: str_ reveal_type(np.datetime_as_string(AR_M)) # E: ndarray[Any, dtype[str_]] reveal_type(np.busdaycalendar(holidays=date_seq)) # E: busdaycalendar reveal_type(np.busdaycalendar(holidays=[M])) # E: busdaycalendar reveal_type(np.compare_chararrays("a", "b", "!=", rstrip=False)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.compare_chararrays(b"a", b"a", "==", True)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.add_docstring(func, "test")) # E: None reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["c_index"])) # E: tuple[nditer, ...] reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["readonly", "readonly"]])) # E: tuple[nditer, ...] reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_dtypes=np.int_)) # E: tuple[nditer, ...] reveal_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], order="C", casting="no")) # E: tuple[nditer, ...] PKIZ}99data/reveal/version.pyinu[import numpy.version reveal_type(numpy.version.version) # E: str reveal_type(numpy.version.__version__) # E: str reveal_type(numpy.version.full_version) # E: str reveal_type(numpy.version.git_revision) # E: str reveal_type(numpy.version.release) # E: bool reveal_type(numpy.version.short_version) # E: str PKIZtF!data/reveal/nbit_base_example.pyinu[from __future__ import annotations from typing import TypeVar import numpy as np import numpy.typing as npt T1 = TypeVar("T1", bound=npt.NBitBase) T2 = TypeVar("T2", bound=npt.NBitBase) def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[T1 | T2]: return a + b i8: np.int64 i4: np.int32 f8: np.float64 f4: np.float32 reveal_type(add(f8, i8)) # E: {float64} reveal_type(add(f4, i8)) # E: {float64} reveal_type(add(f8, i4)) # E: {float64} reveal_type(add(f4, i4)) # E: {float32} PKIZ*N!#data/reveal/warnings_and_errors.pyinu[import numpy as np reveal_type(np.ModuleDeprecationWarning()) # E: ModuleDeprecationWarning reveal_type(np.VisibleDeprecationWarning()) # E: VisibleDeprecationWarning reveal_type(np.ComplexWarning()) # E: ComplexWarning reveal_type(np.RankWarning()) # E: RankWarning reveal_type(np.TooHardError()) # E: TooHardError reveal_type(np.AxisError("test")) # E: AxisError reveal_type(np.AxisError(5, 1)) # E: AxisError PKIZd4 2yy"data/reveal/ndarray_conversion.pyinu[import numpy as np import numpy.typing as npt nd: npt.NDArray[np.int_] = np.array([[1, 2], [3, 4]]) # item reveal_type(nd.item()) # E: int reveal_type(nd.item(1)) # E: int reveal_type(nd.item(0, 1)) # E: int reveal_type(nd.item((0, 1))) # E: int # tolist reveal_type(nd.tolist()) # E: Any # itemset does not return a value # tostring is pretty simple # tobytes is pretty simple # tofile does not return a value # dump does not return a value # dumps is pretty simple # astype reveal_type(nd.astype("float")) # E: ndarray[Any, dtype[Any]] reveal_type(nd.astype(float)) # E: ndarray[Any, dtype[Any]] reveal_type(nd.astype(np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(nd.astype(np.float64, "K")) # E: ndarray[Any, dtype[{float64}]] reveal_type(nd.astype(np.float64, "K", "unsafe")) # E: ndarray[Any, dtype[{float64}]] reveal_type(nd.astype(np.float64, "K", "unsafe", True)) # E: ndarray[Any, dtype[{float64}]] reveal_type(nd.astype(np.float64, "K", "unsafe", True, True)) # E: ndarray[Any, dtype[{float64}]] # byteswap reveal_type(nd.byteswap()) # E: ndarray[Any, dtype[{int_}]] reveal_type(nd.byteswap(True)) # E: ndarray[Any, dtype[{int_}]] # copy reveal_type(nd.copy()) # E: ndarray[Any, dtype[{int_}]] reveal_type(nd.copy("C")) # E: ndarray[Any, dtype[{int_}]] reveal_type(nd.view()) # E: ndarray[Any, dtype[{int_}]] reveal_type(nd.view(np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(nd.view(float)) # E: ndarray[Any, dtype[Any]] reveal_type(nd.view(np.float64, np.matrix)) # E: matrix[Any, Any] # getfield reveal_type(nd.getfield("float")) # E: ndarray[Any, dtype[Any]] reveal_type(nd.getfield(float)) # E: ndarray[Any, dtype[Any]] reveal_type(nd.getfield(np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(nd.getfield(np.float64, 8)) # E: ndarray[Any, dtype[{float64}]] # setflags does not return a value # fill does not return a value PKIZ&uudata/reveal/ndarray_misc.pyinu[""" Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods. More extensive tests are performed for the methods' function-based counterpart in `../from_numeric.py`. """ import operator import ctypes as ct from typing import Any import numpy as np from numpy._typing import NDArray class SubClass(NDArray[np.object_]): ... f8: np.float64 B: SubClass AR_f8: NDArray[np.float64] AR_i8: NDArray[np.int64] AR_U: NDArray[np.str_] AR_V: NDArray[np.void] ctypes_obj = AR_f8.ctypes reveal_type(AR_f8.__dlpack__()) # E: Any reveal_type(AR_f8.__dlpack_device__()) # E: Tuple[int, Literal[0]] reveal_type(ctypes_obj.data) # E: int reveal_type(ctypes_obj.shape) # E: ctypes.Array[{c_intp}] reveal_type(ctypes_obj.strides) # E: ctypes.Array[{c_intp}] reveal_type(ctypes_obj._as_parameter_) # E: ctypes.c_void_p reveal_type(ctypes_obj.data_as(ct.c_void_p)) # E: ctypes.c_void_p reveal_type(ctypes_obj.shape_as(ct.c_longlong)) # E: ctypes.Array[ctypes.c_longlong] reveal_type(ctypes_obj.strides_as(ct.c_ubyte)) # E: ctypes.Array[ctypes.c_ubyte] reveal_type(f8.all()) # E: bool_ reveal_type(AR_f8.all()) # E: bool_ reveal_type(AR_f8.all(axis=0)) # E: Any reveal_type(AR_f8.all(keepdims=True)) # E: Any reveal_type(AR_f8.all(out=B)) # E: SubClass reveal_type(f8.any()) # E: bool_ reveal_type(AR_f8.any()) # E: bool_ reveal_type(AR_f8.any(axis=0)) # E: Any reveal_type(AR_f8.any(keepdims=True)) # E: Any reveal_type(AR_f8.any(out=B)) # E: SubClass reveal_type(f8.argmax()) # E: {intp} reveal_type(AR_f8.argmax()) # E: {intp} reveal_type(AR_f8.argmax(axis=0)) # E: Any reveal_type(AR_f8.argmax(out=B)) # E: SubClass reveal_type(f8.argmin()) # E: {intp} reveal_type(AR_f8.argmin()) # E: {intp} reveal_type(AR_f8.argmin(axis=0)) # E: Any reveal_type(AR_f8.argmin(out=B)) # E: SubClass reveal_type(f8.argsort()) # E: ndarray[Any, Any] reveal_type(AR_f8.argsort()) # E: ndarray[Any, Any] reveal_type(f8.astype(np.int64).choose([()])) # E: ndarray[Any, Any] reveal_type(AR_f8.choose([0])) # E: ndarray[Any, Any] reveal_type(AR_f8.choose([0], out=B)) # E: SubClass reveal_type(f8.clip(1)) # E: Any reveal_type(AR_f8.clip(1)) # E: Any reveal_type(AR_f8.clip(None, 1)) # E: Any reveal_type(AR_f8.clip(1, out=B)) # E: SubClass reveal_type(AR_f8.clip(None, 1, out=B)) # E: SubClass reveal_type(f8.compress([0])) # E: ndarray[Any, Any] reveal_type(AR_f8.compress([0])) # E: ndarray[Any, Any] reveal_type(AR_f8.compress([0], out=B)) # E: SubClass reveal_type(f8.conj()) # E: {float64} reveal_type(AR_f8.conj()) # E: ndarray[Any, dtype[{float64}]] reveal_type(B.conj()) # E: SubClass reveal_type(f8.conjugate()) # E: {float64} reveal_type(AR_f8.conjugate()) # E: ndarray[Any, dtype[{float64}]] reveal_type(B.conjugate()) # E: SubClass reveal_type(f8.cumprod()) # E: ndarray[Any, Any] reveal_type(AR_f8.cumprod()) # E: ndarray[Any, Any] reveal_type(AR_f8.cumprod(out=B)) # E: SubClass reveal_type(f8.cumsum()) # E: ndarray[Any, Any] reveal_type(AR_f8.cumsum()) # E: ndarray[Any, Any] reveal_type(AR_f8.cumsum(out=B)) # E: SubClass reveal_type(f8.max()) # E: Any reveal_type(AR_f8.max()) # E: Any reveal_type(AR_f8.max(axis=0)) # E: Any reveal_type(AR_f8.max(keepdims=True)) # E: Any reveal_type(AR_f8.max(out=B)) # E: SubClass reveal_type(f8.mean()) # E: Any reveal_type(AR_f8.mean()) # E: Any reveal_type(AR_f8.mean(axis=0)) # E: Any reveal_type(AR_f8.mean(keepdims=True)) # E: Any reveal_type(AR_f8.mean(out=B)) # E: SubClass reveal_type(f8.min()) # E: Any reveal_type(AR_f8.min()) # E: Any reveal_type(AR_f8.min(axis=0)) # E: Any reveal_type(AR_f8.min(keepdims=True)) # E: Any reveal_type(AR_f8.min(out=B)) # E: SubClass reveal_type(f8.newbyteorder()) # E: {float64} reveal_type(AR_f8.newbyteorder()) # E: ndarray[Any, dtype[{float64}]] reveal_type(B.newbyteorder('|')) # E: SubClass reveal_type(f8.prod()) # E: Any reveal_type(AR_f8.prod()) # E: Any reveal_type(AR_f8.prod(axis=0)) # E: Any reveal_type(AR_f8.prod(keepdims=True)) # E: Any reveal_type(AR_f8.prod(out=B)) # E: SubClass reveal_type(f8.ptp()) # E: Any reveal_type(AR_f8.ptp()) # E: Any reveal_type(AR_f8.ptp(axis=0)) # E: Any reveal_type(AR_f8.ptp(keepdims=True)) # E: Any reveal_type(AR_f8.ptp(out=B)) # E: SubClass reveal_type(f8.round()) # E: {float64} reveal_type(AR_f8.round()) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_f8.round(out=B)) # E: SubClass reveal_type(f8.repeat(1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_f8.repeat(1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(B.repeat(1)) # E: ndarray[Any, dtype[object_]] reveal_type(f8.std()) # E: Any reveal_type(AR_f8.std()) # E: Any reveal_type(AR_f8.std(axis=0)) # E: Any reveal_type(AR_f8.std(keepdims=True)) # E: Any reveal_type(AR_f8.std(out=B)) # E: SubClass reveal_type(f8.sum()) # E: Any reveal_type(AR_f8.sum()) # E: Any reveal_type(AR_f8.sum(axis=0)) # E: Any reveal_type(AR_f8.sum(keepdims=True)) # E: Any reveal_type(AR_f8.sum(out=B)) # E: SubClass reveal_type(f8.take(0)) # E: {float64} reveal_type(AR_f8.take(0)) # E: {float64} reveal_type(AR_f8.take([0])) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_f8.take(0, out=B)) # E: SubClass reveal_type(AR_f8.take([0], out=B)) # E: SubClass reveal_type(f8.var()) # E: Any reveal_type(AR_f8.var()) # E: Any reveal_type(AR_f8.var(axis=0)) # E: Any reveal_type(AR_f8.var(keepdims=True)) # E: Any reveal_type(AR_f8.var(out=B)) # E: SubClass reveal_type(AR_f8.argpartition([0])) # E: ndarray[Any, dtype[{intp}]] reveal_type(AR_f8.diagonal()) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_f8.dot(1)) # E: ndarray[Any, Any] reveal_type(AR_f8.dot([1])) # E: Any reveal_type(AR_f8.dot(1, out=B)) # E: SubClass reveal_type(AR_f8.nonzero()) # E: tuple[ndarray[Any, dtype[{intp}]], ...] reveal_type(AR_f8.searchsorted(1)) # E: {intp} reveal_type(AR_f8.searchsorted([1])) # E: ndarray[Any, dtype[{intp}]] reveal_type(AR_f8.trace()) # E: Any reveal_type(AR_f8.trace(out=B)) # E: SubClass reveal_type(AR_f8.item()) # E: float reveal_type(AR_U.item()) # E: str reveal_type(AR_f8.ravel()) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_U.ravel()) # E: ndarray[Any, dtype[str_]] reveal_type(AR_f8.flatten()) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_U.flatten()) # E: ndarray[Any, dtype[str_]] reveal_type(AR_f8.reshape(1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(AR_U.reshape(1)) # E: ndarray[Any, dtype[str_]] reveal_type(int(AR_f8)) # E: int reveal_type(int(AR_U)) # E: int reveal_type(float(AR_f8)) # E: float reveal_type(float(AR_U)) # E: float reveal_type(complex(AR_f8)) # E: complex reveal_type(operator.index(AR_i8)) # E: int reveal_type(AR_f8.__array_prepare__(B)) # E: ndarray[Any, dtype[object_]] reveal_type(AR_f8.__array_wrap__(B)) # E: ndarray[Any, dtype[object_]] reveal_type(AR_V[0]) # E: Any reveal_type(AR_V[0, 0]) # E: Any reveal_type(AR_V[AR_i8]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V[AR_i8, AR_i8]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V[AR_i8, None]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V[0, ...]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V[[0]]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V[[0], [0]]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V[:]) # E: ndarray[Any, dtype[void]] reveal_type(AR_V["a"]) # E: ndarray[Any, dtype[Any]] reveal_type(AR_V[["a", "b"]]) # E: ndarray[Any, dtype[void]] reveal_type(AR_f8.dump("test_file")) # E: None reveal_type(AR_f8.dump(b"test_file")) # E: None with open("test_file", "wb") as f: reveal_type(AR_f8.dump(f)) # E: None reveal_type(AR_f8.__array_finalize__(None)) # E: None reveal_type(AR_f8.__array_finalize__(B)) # E: None reveal_type(AR_f8.__array_finalize__(AR_f8)) # E: None PKIZr~,''data/reveal/ufunclike.pyinu[from typing import Any import numpy as np AR_LIKE_b: list[bool] AR_LIKE_u: list[np.uint32] AR_LIKE_i: list[int] AR_LIKE_f: list[float] AR_LIKE_O: list[np.object_] AR_U: np.ndarray[Any, np.dtype[np.str_]] reveal_type(np.fix(AR_LIKE_b)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.fix(AR_LIKE_u)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.fix(AR_LIKE_i)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.fix(AR_LIKE_f)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.fix(AR_LIKE_O)) # E: Any reveal_type(np.fix(AR_LIKE_f, out=AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.isposinf(AR_LIKE_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isposinf(AR_LIKE_u)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isposinf(AR_LIKE_i)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isposinf(AR_LIKE_f)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isposinf(AR_LIKE_f, out=AR_U)) # E: ndarray[Any, dtype[str_]] reveal_type(np.isneginf(AR_LIKE_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isneginf(AR_LIKE_u)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isneginf(AR_LIKE_i)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isneginf(AR_LIKE_f)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isneginf(AR_LIKE_f, out=AR_U)) # E: ndarray[Any, dtype[str_]] PKIZLۈ*data/reveal/ndarray_shape_manipulation.pyinu[import numpy as np nd = np.array([[1, 2], [3, 4]]) # reshape reveal_type(nd.reshape()) # E: ndarray reveal_type(nd.reshape(4)) # E: ndarray reveal_type(nd.reshape(2, 2)) # E: ndarray reveal_type(nd.reshape((2, 2))) # E: ndarray reveal_type(nd.reshape((2, 2), order="C")) # E: ndarray reveal_type(nd.reshape(4, order="C")) # E: ndarray # resize does not return a value # transpose reveal_type(nd.transpose()) # E: ndarray reveal_type(nd.transpose(1, 0)) # E: ndarray reveal_type(nd.transpose((1, 0))) # E: ndarray # swapaxes reveal_type(nd.swapaxes(0, 1)) # E: ndarray # flatten reveal_type(nd.flatten()) # E: ndarray reveal_type(nd.flatten("C")) # E: ndarray # ravel reveal_type(nd.ravel()) # E: ndarray reveal_type(nd.ravel("C")) # E: ndarray # squeeze reveal_type(nd.squeeze()) # E: ndarray reveal_type(nd.squeeze(0)) # E: ndarray reveal_type(nd.squeeze((0, 2))) # E: ndarray PKIZ=Fdata/reveal/nditer.pyinu[import numpy as np nditer_obj: np.nditer reveal_type(np.nditer([0, 1], flags=["c_index"])) # E: nditer reveal_type(np.nditer([0, 1], op_flags=[["readonly", "readonly"]])) # E: nditer reveal_type(np.nditer([0, 1], op_dtypes=np.int_)) # E: nditer reveal_type(np.nditer([0, 1], order="C", casting="no")) # E: nditer reveal_type(nditer_obj.dtypes) # E: tuple[dtype[Any], ...] reveal_type(nditer_obj.finished) # E: bool reveal_type(nditer_obj.has_delayed_bufalloc) # E: bool reveal_type(nditer_obj.has_index) # E: bool reveal_type(nditer_obj.has_multi_index) # E: bool reveal_type(nditer_obj.index) # E: int reveal_type(nditer_obj.iterationneedsapi) # E: bool reveal_type(nditer_obj.iterindex) # E: int reveal_type(nditer_obj.iterrange) # E: tuple[builtins.int, ...] reveal_type(nditer_obj.itersize) # E: int reveal_type(nditer_obj.itviews) # E: tuple[ndarray[Any, dtype[Any]], ...] reveal_type(nditer_obj.multi_index) # E: tuple[builtins.int, ...] reveal_type(nditer_obj.ndim) # E: int reveal_type(nditer_obj.nop) # E: int reveal_type(nditer_obj.operands) # E: tuple[ndarray[Any, dtype[Any]], ...] reveal_type(nditer_obj.shape) # E: tuple[builtins.int, ...] reveal_type(nditer_obj.value) # E: tuple[ndarray[Any, dtype[Any]], ...] reveal_type(nditer_obj.close()) # E: None reveal_type(nditer_obj.copy()) # E: nditer reveal_type(nditer_obj.debug_print()) # E: None reveal_type(nditer_obj.enable_external_loop()) # E: None reveal_type(nditer_obj.iternext()) # E: bool reveal_type(nditer_obj.remove_axis(0)) # E: None reveal_type(nditer_obj.remove_multi_index()) # E: None reveal_type(nditer_obj.reset()) # E: None reveal_type(len(nditer_obj)) # E: int reveal_type(iter(nditer_obj)) # E: nditer reveal_type(next(nditer_obj)) # E: tuple[ndarray[Any, dtype[Any]], ...] reveal_type(nditer_obj.__copy__()) # E: nditer with nditer_obj as f: reveal_type(f) # E: nditer reveal_type(nditer_obj[0]) # E: ndarray[Any, dtype[Any]] reveal_type(nditer_obj[:]) # E: tuple[ndarray[Any, dtype[Any]], ...] nditer_obj[0] = 0 nditer_obj[:] = [0, 1] PKIZR;data/reveal/nested_sequence.pyinu[from collections.abc import Sequence from typing import Any from numpy._typing import _NestedSequence a: Sequence[int] b: Sequence[Sequence[int]] c: Sequence[Sequence[Sequence[int]]] d: Sequence[Sequence[Sequence[Sequence[int]]]] e: Sequence[bool] f: tuple[int, ...] g: list[int] h: Sequence[Any] def func(a: _NestedSequence[int]) -> None: ... reveal_type(func(a)) # E: None reveal_type(func(b)) # E: None reveal_type(func(c)) # E: None reveal_type(func(d)) # E: None reveal_type(func(e)) # E: None reveal_type(func(f)) # E: None reveal_type(func(g)) # E: None reveal_type(func(h)) # E: None reveal_type(func(range(15))) # E: None PKIZ;RRdata/reveal/npyio.pyinu[import re import pathlib from typing import IO import numpy.typing as npt import numpy as np str_path: str pathlib_path: pathlib.Path str_file: IO[str] bytes_file: IO[bytes] bag_obj: np.lib.npyio.BagObj[int] npz_file: np.lib.npyio.NpzFile AR_i8: npt.NDArray[np.int64] AR_LIKE_f8: list[float] class BytesWriter: def write(self, data: bytes) -> None: ... class BytesReader: def read(self, n: int = ...) -> bytes: ... def seek(self, offset: int, whence: int = ...) -> int: ... bytes_writer: BytesWriter bytes_reader: BytesReader reveal_type(bag_obj.a) # E: int reveal_type(bag_obj.b) # E: int reveal_type(npz_file.zip) # E: zipfile.ZipFile reveal_type(npz_file.fid) # E: Union[None, typing.IO[builtins.str]] reveal_type(npz_file.files) # E: list[builtins.str] reveal_type(npz_file.allow_pickle) # E: bool reveal_type(npz_file.pickle_kwargs) # E: Union[None, typing.Mapping[builtins.str, Any]] reveal_type(npz_file.f) # E: lib.npyio.BagObj[lib.npyio.NpzFile] reveal_type(npz_file["test"]) # E: ndarray[Any, dtype[Any]] reveal_type(len(npz_file)) # E: int with npz_file as f: reveal_type(f) # E: lib.npyio.NpzFile reveal_type(np.load(bytes_file)) # E: Any reveal_type(np.load(pathlib_path, allow_pickle=True)) # E: Any reveal_type(np.load(str_path, encoding="bytes")) # E: Any reveal_type(np.load(bytes_reader)) # E: Any reveal_type(np.save(bytes_file, AR_LIKE_f8)) # E: None reveal_type(np.save(pathlib_path, AR_i8, allow_pickle=True)) # E: None reveal_type(np.save(str_path, AR_LIKE_f8)) # E: None reveal_type(np.save(bytes_writer, AR_LIKE_f8)) # E: None reveal_type(np.savez(bytes_file, AR_LIKE_f8)) # E: None reveal_type(np.savez(pathlib_path, ar1=AR_i8, ar2=AR_i8)) # E: None reveal_type(np.savez(str_path, AR_LIKE_f8, ar1=AR_i8)) # E: None reveal_type(np.savez(bytes_writer, AR_LIKE_f8, ar1=AR_i8)) # E: None reveal_type(np.savez_compressed(bytes_file, AR_LIKE_f8)) # E: None reveal_type(np.savez_compressed(pathlib_path, ar1=AR_i8, ar2=AR_i8)) # E: None reveal_type(np.savez_compressed(str_path, AR_LIKE_f8, ar1=AR_i8)) # E: None reveal_type(np.savez_compressed(bytes_writer, AR_LIKE_f8, ar1=AR_i8)) # E: None reveal_type(np.loadtxt(bytes_file)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.loadtxt(pathlib_path, dtype=np.str_)) # E: ndarray[Any, dtype[str_]] reveal_type(np.loadtxt(str_path, dtype=str, skiprows=2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.loadtxt(str_file, comments="test")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.loadtxt(str_file, comments=None)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.loadtxt(str_path, delimiter="\n")) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.loadtxt(str_path, ndmin=2)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.loadtxt(["1", "2", "3"])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromregex(bytes_file, "test", np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromregex(str_file, b"test", dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.fromregex(str_path, re.compile("test"), dtype=np.str_, encoding="utf8")) # E: ndarray[Any, dtype[str_]] reveal_type(np.fromregex(pathlib_path, "test", np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.fromregex(bytes_reader, "test", np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.genfromtxt(bytes_file)) # E: ndarray[Any, dtype[Any]] reveal_type(np.genfromtxt(pathlib_path, dtype=np.str_)) # E: ndarray[Any, dtype[str_]] reveal_type(np.genfromtxt(str_path, dtype=str, skip_header=2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.genfromtxt(str_file, comments="test")) # E: ndarray[Any, dtype[Any]] reveal_type(np.genfromtxt(str_path, delimiter="\n")) # E: ndarray[Any, dtype[Any]] reveal_type(np.genfromtxt(str_path, ndmin=2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.genfromtxt(["1", "2", "3"], ndmin=2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.recfromtxt(bytes_file)) # E: recarray[Any, dtype[record]] reveal_type(np.recfromtxt(pathlib_path, usemask=True)) # E: ma.mrecords.MaskedRecords[Any, dtype[void]] reveal_type(np.recfromtxt(["1", "2", "3"])) # E: recarray[Any, dtype[record]] reveal_type(np.recfromcsv(bytes_file)) # E: recarray[Any, dtype[record]] reveal_type(np.recfromcsv(pathlib_path, usemask=True)) # E: ma.mrecords.MaskedRecords[Any, dtype[void]] reveal_type(np.recfromcsv(["1", "2", "3"])) # E: recarray[Any, dtype[record]] PKIZ[0data/reveal/numeric.pyinu[""" Tests for :mod:`core.numeric`. Does not include tests which fall under ``array_constructors``. """ import numpy as np import numpy.typing as npt class SubClass(npt.NDArray[np.int64]): ... i8: np.int64 AR_b: npt.NDArray[np.bool_] AR_u8: npt.NDArray[np.uint64] AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] AR_m: npt.NDArray[np.timedelta64] AR_O: npt.NDArray[np.object_] B: list[int] C: SubClass reveal_type(np.count_nonzero(i8)) # E: int reveal_type(np.count_nonzero(AR_i8)) # E: int reveal_type(np.count_nonzero(B)) # E: int reveal_type(np.count_nonzero(AR_i8, keepdims=True)) # E: Any reveal_type(np.count_nonzero(AR_i8, axis=0)) # E: Any reveal_type(np.isfortran(i8)) # E: bool reveal_type(np.isfortran(AR_i8)) # E: bool reveal_type(np.argwhere(i8)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.argwhere(AR_i8)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.flatnonzero(i8)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.flatnonzero(AR_i8)) # E: ndarray[Any, dtype[{intp}]] reveal_type(np.correlate(B, AR_i8, mode="valid")) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.correlate(AR_i8, AR_i8, mode="same")) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.correlate(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.correlate(AR_b, AR_u8)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.correlate(AR_i8, AR_b)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.correlate(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.correlate(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.correlate(AR_i8, AR_m)) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.correlate(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.convolve(B, AR_i8, mode="valid")) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.convolve(AR_i8, AR_i8, mode="same")) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.convolve(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.convolve(AR_b, AR_u8)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.convolve(AR_i8, AR_b)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.convolve(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.convolve(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.convolve(AR_i8, AR_m)) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.convolve(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.outer(i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.outer(B, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.outer(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.outer(AR_i8, AR_i8, out=C)) # E: SubClass reveal_type(np.outer(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.outer(AR_b, AR_u8)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.outer(AR_i8, AR_b)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.convolve(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.outer(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.outer(AR_i8, AR_m)) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.outer(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.tensordot(B, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.tensordot(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.tensordot(AR_i8, AR_i8, axes=0)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.tensordot(AR_i8, AR_i8, axes=(0, 1))) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.tensordot(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.tensordot(AR_b, AR_u8)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.tensordot(AR_i8, AR_b)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.tensordot(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.tensordot(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.tensordot(AR_i8, AR_m)) # E: ndarray[Any, dtype[timedelta64]] reveal_type(np.tensordot(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.isscalar(i8)) # E: bool reveal_type(np.isscalar(AR_i8)) # E: bool reveal_type(np.isscalar(B)) # E: bool reveal_type(np.roll(AR_i8, 1)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.roll(AR_i8, (1, 2))) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.roll(B, 1)) # E: ndarray[Any, dtype[Any]] reveal_type(np.rollaxis(AR_i8, 0, 1)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.moveaxis(AR_i8, 0, 1)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.moveaxis(AR_i8, (0, 1), (1, 2))) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.cross(B, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.cross(AR_i8, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.cross(AR_b, AR_u8)) # E: ndarray[Any, dtype[unsignedinteger[Any]]] reveal_type(np.cross(AR_i8, AR_b)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.cross(AR_i8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.cross(AR_i8, AR_c16)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.cross(AR_O, AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.indices([0, 1, 2])) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.indices([0, 1, 2], sparse=True)) # E: tuple[ndarray[Any, dtype[{int_}]], ...] reveal_type(np.indices([0, 1, 2], dtype=np.float64)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.indices([0, 1, 2], sparse=True, dtype=np.float64)) # E: tuple[ndarray[Any, dtype[{float64}]], ...] reveal_type(np.indices([0, 1, 2], dtype=float)) # E: ndarray[Any, dtype[Any]] reveal_type(np.indices([0, 1, 2], sparse=True, dtype=float)) # E: tuple[ndarray[Any, dtype[Any]], ...] reveal_type(np.binary_repr(1)) # E: str reveal_type(np.base_repr(1)) # E: str reveal_type(np.allclose(i8, AR_i8)) # E: bool reveal_type(np.allclose(B, AR_i8)) # E: bool reveal_type(np.allclose(AR_i8, AR_i8)) # E: bool reveal_type(np.isclose(i8, i8)) # E: bool_ reveal_type(np.isclose(i8, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isclose(B, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isclose(AR_i8, AR_i8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.array_equal(i8, AR_i8)) # E: bool reveal_type(np.array_equal(B, AR_i8)) # E: bool reveal_type(np.array_equal(AR_i8, AR_i8)) # E: bool reveal_type(np.array_equiv(i8, AR_i8)) # E: bool reveal_type(np.array_equiv(B, AR_i8)) # E: bool reveal_type(np.array_equiv(AR_i8, AR_i8)) # E: bool PKIZD#data/reveal/numerictypes.pyinu[import numpy as np reveal_type(np.maximum_sctype(np.float64)) # E: Type[{float64}] reveal_type(np.maximum_sctype("f8")) # E: Type[Any] reveal_type(np.issctype(np.float64)) # E: bool reveal_type(np.issctype("foo")) # E: Literal[False] reveal_type(np.obj2sctype(np.float64)) # E: Union[None, Type[{float64}]] reveal_type(np.obj2sctype(np.float64, default=False)) # E: Union[builtins.bool, Type[{float64}]] reveal_type(np.obj2sctype("S8")) # E: Union[None, Type[Any]] reveal_type(np.obj2sctype("S8", default=None)) # E: Union[None, Type[Any]] reveal_type(np.obj2sctype("foo", default=False)) # E: Union[builtins.bool, Type[Any]] reveal_type(np.obj2sctype(1)) # E: None reveal_type(np.obj2sctype(1, default=False)) # E: bool reveal_type(np.issubclass_(np.float64, float)) # E: bool reveal_type(np.issubclass_(np.float64, (int, float))) # E: bool reveal_type(np.issubclass_(1, 1)) # E: Literal[False] reveal_type(np.sctype2char("S8")) # E: str reveal_type(np.sctype2char(list)) # E: str reveal_type(np.cast[int]) # E: _CastFunc reveal_type(np.cast["i8"]) # E: _CastFunc reveal_type(np.cast[np.int64]) # E: _CastFunc reveal_type(np.nbytes[int]) # E: int reveal_type(np.nbytes["i8"]) # E: int reveal_type(np.nbytes[np.int64]) # E: int reveal_type(np.ScalarType) # E: Tuple reveal_type(np.ScalarType[0]) # E: Type[builtins.int] reveal_type(np.ScalarType[3]) # E: Type[builtins.bool] reveal_type(np.ScalarType[8]) # E: Type[{csingle}] reveal_type(np.ScalarType[10]) # E: Type[{clongdouble}] reveal_type(np.typecodes["Character"]) # E: Literal['c'] reveal_type(np.typecodes["Complex"]) # E: Literal['FDG'] reveal_type(np.typecodes["All"]) # E: Literal['?bhilqpBHILQPefdgFDGSUVOMm'] PKIZYOdata/reveal/random.pyinu[from __future__ import annotations from typing import Any import numpy as np def_rng = np.random.default_rng() seed_seq = np.random.SeedSequence() mt19937 = np.random.MT19937() pcg64 = np.random.PCG64() sfc64 = np.random.SFC64() philox = np.random.Philox() seedless_seq = np.random.bit_generator.SeedlessSeedSequence() reveal_type(def_rng) # E: random._generator.Generator reveal_type(mt19937) # E: random._mt19937.MT19937 reveal_type(pcg64) # E: random._pcg64.PCG64 reveal_type(sfc64) # E: random._sfc64.SFC64 reveal_type(philox) # E: random._philox.Philox reveal_type(seed_seq) # E: random.bit_generator.SeedSequence reveal_type(seedless_seq) # E: random.bit_generator.SeedlessSeedSequence mt19937_jumped = mt19937.jumped() mt19937_jumped3 = mt19937.jumped(3) mt19937_raw = mt19937.random_raw() mt19937_raw_arr = mt19937.random_raw(5) reveal_type(mt19937_jumped) # E: random._mt19937.MT19937 reveal_type(mt19937_jumped3) # E: random._mt19937.MT19937 reveal_type(mt19937_raw) # E: int reveal_type(mt19937_raw_arr) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(mt19937.lock) # E: threading.Lock pcg64_jumped = pcg64.jumped() pcg64_jumped3 = pcg64.jumped(3) pcg64_adv = pcg64.advance(3) pcg64_raw = pcg64.random_raw() pcg64_raw_arr = pcg64.random_raw(5) reveal_type(pcg64_jumped) # E: random._pcg64.PCG64 reveal_type(pcg64_jumped3) # E: random._pcg64.PCG64 reveal_type(pcg64_adv) # E: random._pcg64.PCG64 reveal_type(pcg64_raw) # E: int reveal_type(pcg64_raw_arr) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(pcg64.lock) # E: threading.Lock philox_jumped = philox.jumped() philox_jumped3 = philox.jumped(3) philox_adv = philox.advance(3) philox_raw = philox.random_raw() philox_raw_arr = philox.random_raw(5) reveal_type(philox_jumped) # E: random._philox.Philox reveal_type(philox_jumped3) # E: random._philox.Philox reveal_type(philox_adv) # E: random._philox.Philox reveal_type(philox_raw) # E: int reveal_type(philox_raw_arr) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(philox.lock) # E: threading.Lock sfc64_raw = sfc64.random_raw() sfc64_raw_arr = sfc64.random_raw(5) reveal_type(sfc64_raw) # E: int reveal_type(sfc64_raw_arr) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(sfc64.lock) # E: threading.Lock reveal_type(seed_seq.pool) # ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(seed_seq.entropy) # E:Union[None, int, Sequence[int]] reveal_type(seed_seq.spawn(1)) # E: list[random.bit_generator.SeedSequence] reveal_type(seed_seq.generate_state(8, "uint32")) # E: ndarray[Any, dtype[Union[unsignedinteger[typing._32Bit], unsignedinteger[typing._64Bit]]]] reveal_type(seed_seq.generate_state(8, "uint64")) # E: ndarray[Any, dtype[Union[unsignedinteger[typing._32Bit], unsignedinteger[typing._64Bit]]]] def_gen: np.random.Generator = np.random.default_rng() D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1]) D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5]) D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9]) D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5]) I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_) I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_) D_arr_like_0p1: list[float] = [0.1] D_arr_like_0p5: list[float] = [0.5] D_arr_like_0p9: list[float] = [0.9] D_arr_like_1p5: list[float] = [1.5] I_arr_like_10: list[int] = [10] I_arr_like_20: list[int] = [20] D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]] D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like) S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32) D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1) reveal_type(def_gen.standard_normal()) # E: float reveal_type(def_gen.standard_normal(dtype=np.float32)) # E: float reveal_type(def_gen.standard_normal(dtype="float32")) # E: float reveal_type(def_gen.standard_normal(dtype="double")) # E: float reveal_type(def_gen.standard_normal(dtype=np.float64)) # E: float reveal_type(def_gen.standard_normal(size=None)) # E: float reveal_type(def_gen.standard_normal(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype=np.float32)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype="f4")) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype="float32", out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_normal(dtype=np.float32, out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype=np.float64)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype="float64")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype="f8")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_normal(out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype="float64")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_normal(size=1, dtype="float64", out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random()) # E: float reveal_type(def_gen.random(dtype=np.float32)) # E: float reveal_type(def_gen.random(dtype="float32")) # E: float reveal_type(def_gen.random(dtype="double")) # E: float reveal_type(def_gen.random(dtype=np.float64)) # E: float reveal_type(def_gen.random(size=None)) # E: float reveal_type(def_gen.random(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random(size=1, dtype=np.float32)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.random(size=1, dtype="f4")) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.random(size=1, dtype="float32", out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.random(dtype=np.float32, out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.random(size=1, dtype=np.float64)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random(size=1, dtype="float64")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random(size=1, dtype="f8")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random(out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random(size=1, dtype="float64")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.random(size=1, dtype="float64", out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_cauchy()) # E: float reveal_type(def_gen.standard_cauchy(size=None)) # E: float reveal_type(def_gen.standard_cauchy(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_exponential()) # E: float reveal_type(def_gen.standard_exponential(method="inv")) # E: float reveal_type(def_gen.standard_exponential(dtype=np.float32)) # E: float reveal_type(def_gen.standard_exponential(dtype="float32")) # E: float reveal_type(def_gen.standard_exponential(dtype="double")) # E: float reveal_type(def_gen.standard_exponential(dtype=np.float64)) # E: float reveal_type(def_gen.standard_exponential(size=None)) # E: float reveal_type(def_gen.standard_exponential(size=None, method="inv")) # E: float reveal_type(def_gen.standard_exponential(size=1, method="inv")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype=np.float32)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype="f4", method="inv")) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype="float32", out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_exponential(dtype=np.float32, out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype=np.float64, method="inv")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype="float64")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype="f8")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_exponential(out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype="float64")) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_exponential(size=1, dtype="float64", out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.zipf(1.5)) # E: int reveal_type(def_gen.zipf(1.5, size=None)) # E: int reveal_type(def_gen.zipf(1.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.zipf(D_arr_1p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.zipf(D_arr_1p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.zipf(D_arr_like_1p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.zipf(D_arr_like_1p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.weibull(0.5)) # E: float reveal_type(def_gen.weibull(0.5, size=None)) # E: float reveal_type(def_gen.weibull(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.weibull(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.weibull(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.weibull(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.weibull(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_t(0.5)) # E: float reveal_type(def_gen.standard_t(0.5, size=None)) # E: float reveal_type(def_gen.standard_t(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_t(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_t(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_t(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_t(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.poisson(0.5)) # E: int reveal_type(def_gen.poisson(0.5, size=None)) # E: int reveal_type(def_gen.poisson(0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.poisson(D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.poisson(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.poisson(D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.poisson(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.power(0.5)) # E: float reveal_type(def_gen.power(0.5, size=None)) # E: float reveal_type(def_gen.power(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.power(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.power(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.power(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.power(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.pareto(0.5)) # E: float reveal_type(def_gen.pareto(0.5, size=None)) # E: float reveal_type(def_gen.pareto(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.pareto(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.pareto(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.pareto(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.pareto(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.chisquare(0.5)) # E: float reveal_type(def_gen.chisquare(0.5, size=None)) # E: float reveal_type(def_gen.chisquare(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.chisquare(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.chisquare(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.chisquare(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.chisquare(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.exponential(0.5)) # E: float reveal_type(def_gen.exponential(0.5, size=None)) # E: float reveal_type(def_gen.exponential(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.exponential(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.exponential(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.exponential(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.exponential(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.geometric(0.5)) # E: int reveal_type(def_gen.geometric(0.5, size=None)) # E: int reveal_type(def_gen.geometric(0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.geometric(D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.geometric(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.geometric(D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.geometric(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.logseries(0.5)) # E: int reveal_type(def_gen.logseries(0.5, size=None)) # E: int reveal_type(def_gen.logseries(0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.logseries(D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.logseries(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.logseries(D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.logseries(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.rayleigh(0.5)) # E: float reveal_type(def_gen.rayleigh(0.5, size=None)) # E: float reveal_type(def_gen.rayleigh(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.rayleigh(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.rayleigh(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.rayleigh(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.rayleigh(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.standard_gamma(0.5)) # E: float reveal_type(def_gen.standard_gamma(0.5, size=None)) # E: float reveal_type(def_gen.standard_gamma(0.5, dtype="float32")) # E: float reveal_type(def_gen.standard_gamma(0.5, size=None, dtype="float32")) # E: float reveal_type(def_gen.standard_gamma(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_0p5, dtype="f4")) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out)) # E: ndarray[Any, dtype[floating[typing._32Bit]]] reveal_type(def_gen.standard_gamma(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(0.5, out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_like_0p5, out=D_out)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(def_gen.vonmises(0.5, 0.5)) # E: float reveal_type(def_gen.vonmises(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.vonmises(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(0.5, 0.5)) # E: float reveal_type(def_gen.wald(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.wald(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(0.5, 0.5)) # E: float reveal_type(def_gen.uniform(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.uniform(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(0.5, 0.5)) # E: float reveal_type(def_gen.beta(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.beta(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(0.5, 0.5)) # E: float reveal_type(def_gen.f(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.f(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(0.5, 0.5)) # E: float reveal_type(def_gen.gamma(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.gamma(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(0.5, 0.5)) # E: float reveal_type(def_gen.gumbel(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.gumbel(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(0.5, 0.5)) # E: float reveal_type(def_gen.laplace(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.laplace(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(0.5, 0.5)) # E: float reveal_type(def_gen.logistic(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.logistic(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(0.5, 0.5)) # E: float reveal_type(def_gen.lognormal(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.lognormal(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(0.5, 0.5)) # E: float reveal_type(def_gen.noncentral_chisquare(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.noncentral_chisquare(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(0.5, 0.5)) # E: float reveal_type(def_gen.normal(0.5, 0.5, size=None)) # E: float reveal_type(def_gen.normal(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(0.1, 0.5, 0.9)) # E: float reveal_type(def_gen.triangular(0.1, 0.5, 0.9, size=None)) # E: float reveal_type(def_gen.triangular(0.1, 0.5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_0p1, 0.5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(0.1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(0.5, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9)) # E: float reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=None)) # E: float reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.binomial(10, 0.5)) # E: int reveal_type(def_gen.binomial(10, 0.5, size=None)) # E: int reveal_type(def_gen.binomial(10, 0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_10, 0.5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(10, D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_10, 0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_like_10, 0.5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(10, D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_10, D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(10, 0.5)) # E: int reveal_type(def_gen.negative_binomial(10, 0.5, size=None)) # E: int reveal_type(def_gen.negative_binomial(10, 0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_10, 0.5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(10, D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_10, 0.5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_like_10, 0.5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(10, D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(20, 20, 10)) # E: int reveal_type(def_gen.hypergeometric(20, 20, 10, size=None)) # E: int reveal_type(def_gen.hypergeometric(20, 20, 10, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_20, 20, 10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(20, I_arr_20, 10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(20, I_arr_20, 10, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(20, I_arr_like_20, 10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_20, I_arr_20, 10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] I_int64_100: np.ndarray[Any, np.dtype[np.int64]] = np.array([100], dtype=np.int64) reveal_type(def_gen.integers(0, 100)) # E: int reveal_type(def_gen.integers(100)) # E: int reveal_type(def_gen.integers([100])) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, [100])) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_) I_bool_low_like: list[int] = [0] I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_) I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_) reveal_type(def_gen.integers(2, dtype=bool)) # E: builtins.bool reveal_type(def_gen.integers(0, 2, dtype=bool)) # E: builtins.bool reveal_type(def_gen.integers(1, dtype=bool, endpoint=True)) # E: builtins.bool reveal_type(def_gen.integers(0, 1, dtype=bool, endpoint=True)) # E: builtins.bool reveal_type(def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_high_open, dtype=bool)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(0, I_bool_high_open, dtype=bool)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(2, dtype=np.bool_)) # E: builtins.bool reveal_type(def_gen.integers(0, 2, dtype=np.bool_)) # E: builtins.bool reveal_type(def_gen.integers(1, dtype=np.bool_, endpoint=True)) # E: builtins.bool reveal_type(def_gen.integers(0, 1, dtype=np.bool_, endpoint=True)) # E: builtins.bool reveal_type(def_gen.integers(I_bool_low_like, 1, dtype=np.bool_, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_high_open, dtype=np.bool_)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool_)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(0, I_bool_high_open, dtype=np.bool_)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_high_closed, dtype=np.bool_, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool_, endpoint=True)) # E: ndarray[Any, dtype[bool_] reveal_type(def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True)) # E: ndarray[Any, dtype[bool_] I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8) I_u1_low_like: list[int] = [0] I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8) I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8) reveal_type(def_gen.integers(256, dtype="u1")) # E: int reveal_type(def_gen.integers(0, 256, dtype="u1")) # E: int reveal_type(def_gen.integers(255, dtype="u1", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 255, dtype="u1", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_high_open, dtype="u1")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(0, I_u1_high_open, dtype="u1")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(256, dtype="uint8")) # E: int reveal_type(def_gen.integers(0, 256, dtype="uint8")) # E: int reveal_type(def_gen.integers(255, dtype="uint8", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 255, dtype="uint8", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_high_open, dtype="uint8")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(0, I_u1_high_open, dtype="uint8")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(256, dtype=np.uint8)) # E: int reveal_type(def_gen.integers(0, 256, dtype=np.uint8)) # E: int reveal_type(def_gen.integers(255, dtype=np.uint8, endpoint=True)) # E: int reveal_type(def_gen.integers(0, 255, dtype=np.uint8, endpoint=True)) # E: int reveal_type(def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_high_open, dtype=np.uint8)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(0, I_u1_high_open, dtype=np.uint8)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16) I_u2_low_like: list[int] = [0] I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16) I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16) reveal_type(def_gen.integers(65536, dtype="u2")) # E: int reveal_type(def_gen.integers(0, 65536, dtype="u2")) # E: int reveal_type(def_gen.integers(65535, dtype="u2", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 65535, dtype="u2", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_high_open, dtype="u2")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(0, I_u2_high_open, dtype="u2")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(65536, dtype="uint16")) # E: int reveal_type(def_gen.integers(0, 65536, dtype="uint16")) # E: int reveal_type(def_gen.integers(65535, dtype="uint16", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 65535, dtype="uint16", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_high_open, dtype="uint16")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(0, I_u2_high_open, dtype="uint16")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(65536, dtype=np.uint16)) # E: int reveal_type(def_gen.integers(0, 65536, dtype=np.uint16)) # E: int reveal_type(def_gen.integers(65535, dtype=np.uint16, endpoint=True)) # E: int reveal_type(def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True)) # E: int reveal_type(def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_high_open, dtype=np.uint16)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(0, I_u2_high_open, dtype=np.uint16)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32) I_u4_low_like: list[int] = [0] I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32) I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32) reveal_type(def_gen.integers(4294967296, dtype=np.int_)) # E: int reveal_type(def_gen.integers(0, 4294967296, dtype=np.int_)) # E: int reveal_type(def_gen.integers(4294967295, dtype=np.int_, endpoint=True)) # E: int reveal_type(def_gen.integers(0, 4294967295, dtype=np.int_, endpoint=True)) # E: int reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.int_, endpoint=True)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(I_u4_high_open, dtype=np.int_)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.int_)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(0, I_u4_high_open, dtype=np.int_)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(I_u4_high_closed, dtype=np.int_, endpoint=True)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.int_, endpoint=True)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.int_, endpoint=True)) # E: ndarray[Any, dtype[{int_}]] reveal_type(def_gen.integers(4294967296, dtype="u4")) # E: int reveal_type(def_gen.integers(0, 4294967296, dtype="u4")) # E: int reveal_type(def_gen.integers(4294967295, dtype="u4", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 4294967295, dtype="u4", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_high_open, dtype="u4")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(0, I_u4_high_open, dtype="u4")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(4294967296, dtype="uint32")) # E: int reveal_type(def_gen.integers(0, 4294967296, dtype="uint32")) # E: int reveal_type(def_gen.integers(4294967295, dtype="uint32", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_high_open, dtype="uint32")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(0, I_u4_high_open, dtype="uint32")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(4294967296, dtype=np.uint32)) # E: int reveal_type(def_gen.integers(0, 4294967296, dtype=np.uint32)) # E: int reveal_type(def_gen.integers(4294967295, dtype=np.uint32, endpoint=True)) # E: int reveal_type(def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True)) # E: int reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_high_open, dtype=np.uint32)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(0, I_u4_high_open, dtype=np.uint32)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(def_gen.integers(4294967296, dtype=np.uint)) # E: int reveal_type(def_gen.integers(0, 4294967296, dtype=np.uint)) # E: int reveal_type(def_gen.integers(4294967295, dtype=np.uint, endpoint=True)) # E: int reveal_type(def_gen.integers(0, 4294967295, dtype=np.uint, endpoint=True)) # E: int reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint, endpoint=True)) # E: ndarray[Any, dtype[{uint}]] reveal_type(def_gen.integers(I_u4_high_open, dtype=np.uint)) # E: ndarray[Any, dtype[{uint}]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint)) # E: ndarray[Any, dtype[{uint}]] reveal_type(def_gen.integers(0, I_u4_high_open, dtype=np.uint)) # E: ndarray[Any, dtype[{uint}]] reveal_type(def_gen.integers(I_u4_high_closed, dtype=np.uint, endpoint=True)) # E: ndarray[Any, dtype[{uint}]] reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint, endpoint=True)) # E: ndarray[Any, dtype[{uint}]] reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint, endpoint=True)) # E: ndarray[Any, dtype[{uint}]] I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64) I_u8_low_like: list[int] = [0] I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64) I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64) reveal_type(def_gen.integers(18446744073709551616, dtype="u8")) # E: int reveal_type(def_gen.integers(0, 18446744073709551616, dtype="u8")) # E: int reveal_type(def_gen.integers(18446744073709551615, dtype="u8", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_high_open, dtype="u8")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, I_u8_high_open, dtype="u8")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(18446744073709551616, dtype="uint64")) # E: int reveal_type(def_gen.integers(0, 18446744073709551616, dtype="uint64")) # E: int reveal_type(def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True)) # E: int reveal_type(def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True)) # E: int reveal_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_high_open, dtype="uint64")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, I_u8_high_open, dtype="uint64")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(18446744073709551616, dtype=np.uint64)) # E: int reveal_type(def_gen.integers(0, 18446744073709551616, dtype=np.uint64)) # E: int reveal_type(def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True)) # E: int reveal_type(def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True)) # E: int reveal_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_high_open, dtype=np.uint64)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, I_u8_high_open, dtype=np.uint64)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8) I_i1_low_like: list[int] = [-128] I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8) I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8) reveal_type(def_gen.integers(128, dtype="i1")) # E: int reveal_type(def_gen.integers(-128, 128, dtype="i1")) # E: int reveal_type(def_gen.integers(127, dtype="i1", endpoint=True)) # E: int reveal_type(def_gen.integers(-128, 127, dtype="i1", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_high_open, dtype="i1")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(-128, I_i1_high_open, dtype="i1")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(128, dtype="int8")) # E: int reveal_type(def_gen.integers(-128, 128, dtype="int8")) # E: int reveal_type(def_gen.integers(127, dtype="int8", endpoint=True)) # E: int reveal_type(def_gen.integers(-128, 127, dtype="int8", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_high_open, dtype="int8")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(-128, I_i1_high_open, dtype="int8")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(128, dtype=np.int8)) # E: int reveal_type(def_gen.integers(-128, 128, dtype=np.int8)) # E: int reveal_type(def_gen.integers(127, dtype=np.int8, endpoint=True)) # E: int reveal_type(def_gen.integers(-128, 127, dtype=np.int8, endpoint=True)) # E: int reveal_type(def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_high_open, dtype=np.int8)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(-128, I_i1_high_open, dtype=np.int8)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16) I_i2_low_like: list[int] = [-32768] I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16) I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16) reveal_type(def_gen.integers(32768, dtype="i2")) # E: int reveal_type(def_gen.integers(-32768, 32768, dtype="i2")) # E: int reveal_type(def_gen.integers(32767, dtype="i2", endpoint=True)) # E: int reveal_type(def_gen.integers(-32768, 32767, dtype="i2", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_high_open, dtype="i2")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(-32768, I_i2_high_open, dtype="i2")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(32768, dtype="int16")) # E: int reveal_type(def_gen.integers(-32768, 32768, dtype="int16")) # E: int reveal_type(def_gen.integers(32767, dtype="int16", endpoint=True)) # E: int reveal_type(def_gen.integers(-32768, 32767, dtype="int16", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_high_open, dtype="int16")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(-32768, I_i2_high_open, dtype="int16")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(32768, dtype=np.int16)) # E: int reveal_type(def_gen.integers(-32768, 32768, dtype=np.int16)) # E: int reveal_type(def_gen.integers(32767, dtype=np.int16, endpoint=True)) # E: int reveal_type(def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True)) # E: int reveal_type(def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_high_open, dtype=np.int16)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(-32768, I_i2_high_open, dtype=np.int16)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32) I_i4_low_like: list[int] = [-2147483648] I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32) I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32) reveal_type(def_gen.integers(2147483648, dtype="i4")) # E: int reveal_type(def_gen.integers(-2147483648, 2147483648, dtype="i4")) # E: int reveal_type(def_gen.integers(2147483647, dtype="i4", endpoint=True)) # E: int reveal_type(def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_high_open, dtype="i4")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(-2147483648, I_i4_high_open, dtype="i4")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(2147483648, dtype="int32")) # E: int reveal_type(def_gen.integers(-2147483648, 2147483648, dtype="int32")) # E: int reveal_type(def_gen.integers(2147483647, dtype="int32", endpoint=True)) # E: int reveal_type(def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_high_open, dtype="int32")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(-2147483648, I_i4_high_open, dtype="int32")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(2147483648, dtype=np.int32)) # E: int reveal_type(def_gen.integers(-2147483648, 2147483648, dtype=np.int32)) # E: int reveal_type(def_gen.integers(2147483647, dtype=np.int32, endpoint=True)) # E: int reveal_type(def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True)) # E: int reveal_type(def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_high_open, dtype=np.int32)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64) I_i8_low_like: list[int] = [-9223372036854775808] I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64) I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64) reveal_type(def_gen.integers(9223372036854775808, dtype="i8")) # E: int reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8")) # E: int reveal_type(def_gen.integers(9223372036854775807, dtype="i8", endpoint=True)) # E: int reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_high_open, dtype="i8")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(9223372036854775808, dtype="int64")) # E: int reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64")) # E: int reveal_type(def_gen.integers(9223372036854775807, dtype="int64", endpoint=True)) # E: int reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True)) # E: int reveal_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_high_open, dtype="int64")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(9223372036854775808, dtype=np.int64)) # E: int reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64)) # E: int reveal_type(def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True)) # E: int reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True)) # E: int reveal_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_high_open, dtype=np.int64)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.bit_generator) # E: BitGenerator reveal_type(def_gen.bytes(2)) # E: bytes reveal_type(def_gen.choice(5)) # E: int reveal_type(def_gen.choice(5, 3)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.choice(5, 3, replace=True)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.choice(5, 3, p=[1 / 5] * 5)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"])) # E: Any reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)) # E: ndarray[Any, Any] reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)) # E: ndarray[Any, Any] reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)) # E: ndarray[Any, Any] reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))) # E: ndarray[Any, Any] reveal_type(def_gen.dirichlet([0.5, 0.5])) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.dirichlet(np.array([0.5, 0.5]))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.dirichlet(np.array([0.5, 0.5]), size=3)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.multinomial(20, [1 / 6.0] * 6)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multinomial(20, np.array([0.5, 0.5]))) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multinomial(20, [1 / 6.0] * 6, size=2)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2))) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2))) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7))) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.multivariate_normal([0.0], [[1.0]])) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.multivariate_normal([0.0], np.array([[1.0]]))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.multivariate_normal(np.array([0.0]), [[1.0]])) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.multivariate_normal([0.0], np.array([[1.0]]))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(def_gen.permutation(10)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(def_gen.permutation([1, 2, 3, 4])) # E: ndarray[Any, Any] reveal_type(def_gen.permutation(np.array([1, 2, 3, 4]))) # E: ndarray[Any, Any] reveal_type(def_gen.permutation(D_2D, axis=1)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D_like)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D, axis=1)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D, out=D_2D)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D_like, out=D_2D)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D_like, out=D_2D)) # E: ndarray[Any, Any] reveal_type(def_gen.permuted(D_2D, axis=1, out=D_2D)) # E: ndarray[Any, Any] reveal_type(def_gen.shuffle(np.arange(10))) # E: None reveal_type(def_gen.shuffle([1, 2, 3, 4, 5])) # E: None reveal_type(def_gen.shuffle(D_2D, axis=1)) # E: None reveal_type(np.random.Generator(pcg64)) # E: Generator reveal_type(def_gen.__str__()) # E: str reveal_type(def_gen.__repr__()) # E: str def_gen_state = def_gen.__getstate__() reveal_type(def_gen_state) # E: builtins.dict[builtins.str, Any] reveal_type(def_gen.__setstate__(def_gen_state)) # E: None # RandomState random_st: np.random.RandomState = np.random.RandomState() reveal_type(random_st.standard_normal()) # E: float reveal_type(random_st.standard_normal(size=None)) # E: float reveal_type(random_st.standard_normal(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.random()) # E: float reveal_type(random_st.random(size=None)) # E: float reveal_type(random_st.random(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.standard_cauchy()) # E: float reveal_type(random_st.standard_cauchy(size=None)) # E: float reveal_type(random_st.standard_cauchy(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_exponential()) # E: float reveal_type(random_st.standard_exponential(size=None)) # E: float reveal_type(random_st.standard_exponential(size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.zipf(1.5)) # E: int reveal_type(random_st.zipf(1.5, size=None)) # E: int reveal_type(random_st.zipf(1.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.zipf(D_arr_1p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.zipf(D_arr_1p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.zipf(D_arr_like_1p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.zipf(D_arr_like_1p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.weibull(0.5)) # E: float reveal_type(random_st.weibull(0.5, size=None)) # E: float reveal_type(random_st.weibull(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.weibull(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.weibull(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.weibull(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.weibull(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_t(0.5)) # E: float reveal_type(random_st.standard_t(0.5, size=None)) # E: float reveal_type(random_st.standard_t(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_t(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_t(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_t(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_t(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.poisson(0.5)) # E: int reveal_type(random_st.poisson(0.5, size=None)) # E: int reveal_type(random_st.poisson(0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.poisson(D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.poisson(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.poisson(D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.poisson(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.power(0.5)) # E: float reveal_type(random_st.power(0.5, size=None)) # E: float reveal_type(random_st.power(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.power(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.power(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.power(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.power(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.pareto(0.5)) # E: float reveal_type(random_st.pareto(0.5, size=None)) # E: float reveal_type(random_st.pareto(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.pareto(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.pareto(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.pareto(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.pareto(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.chisquare(0.5)) # E: float reveal_type(random_st.chisquare(0.5, size=None)) # E: float reveal_type(random_st.chisquare(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.chisquare(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.chisquare(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.chisquare(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.chisquare(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.exponential(0.5)) # E: float reveal_type(random_st.exponential(0.5, size=None)) # E: float reveal_type(random_st.exponential(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.exponential(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.exponential(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.exponential(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.exponential(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.geometric(0.5)) # E: int reveal_type(random_st.geometric(0.5, size=None)) # E: int reveal_type(random_st.geometric(0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.geometric(D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.geometric(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.geometric(D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.geometric(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.logseries(0.5)) # E: int reveal_type(random_st.logseries(0.5, size=None)) # E: int reveal_type(random_st.logseries(0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.logseries(D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.logseries(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.logseries(D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.logseries(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.rayleigh(0.5)) # E: float reveal_type(random_st.rayleigh(0.5, size=None)) # E: float reveal_type(random_st.rayleigh(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.rayleigh(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.rayleigh(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.rayleigh(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.rayleigh(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.standard_gamma(0.5)) # E: float reveal_type(random_st.standard_gamma(0.5, size=None)) # E: float reveal_type(random_st.standard_gamma(0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.standard_gamma(D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.standard_gamma(D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.standard_gamma(D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.standard_gamma(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.standard_gamma(D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]]] reveal_type(random_st.vonmises(0.5, 0.5)) # E: float reveal_type(random_st.vonmises(0.5, 0.5, size=None)) # E: float reveal_type(random_st.vonmises(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(0.5, 0.5)) # E: float reveal_type(random_st.wald(0.5, 0.5, size=None)) # E: float reveal_type(random_st.wald(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(0.5, 0.5)) # E: float reveal_type(random_st.uniform(0.5, 0.5, size=None)) # E: float reveal_type(random_st.uniform(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(0.5, 0.5)) # E: float reveal_type(random_st.beta(0.5, 0.5, size=None)) # E: float reveal_type(random_st.beta(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(0.5, 0.5)) # E: float reveal_type(random_st.f(0.5, 0.5, size=None)) # E: float reveal_type(random_st.f(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(0.5, 0.5)) # E: float reveal_type(random_st.gamma(0.5, 0.5, size=None)) # E: float reveal_type(random_st.gamma(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(0.5, 0.5)) # E: float reveal_type(random_st.gumbel(0.5, 0.5, size=None)) # E: float reveal_type(random_st.gumbel(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(0.5, 0.5)) # E: float reveal_type(random_st.laplace(0.5, 0.5, size=None)) # E: float reveal_type(random_st.laplace(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(0.5, 0.5)) # E: float reveal_type(random_st.logistic(0.5, 0.5, size=None)) # E: float reveal_type(random_st.logistic(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(0.5, 0.5)) # E: float reveal_type(random_st.lognormal(0.5, 0.5, size=None)) # E: float reveal_type(random_st.lognormal(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(0.5, 0.5)) # E: float reveal_type(random_st.noncentral_chisquare(0.5, 0.5, size=None)) # E: float reveal_type(random_st.noncentral_chisquare(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(0.5, 0.5)) # E: float reveal_type(random_st.normal(0.5, 0.5, size=None)) # E: float reveal_type(random_st.normal(0.5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(0.5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_0p5, 0.5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(0.5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_like_0p5, 0.5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(0.5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_0p5, D_arr_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_like_0p5, D_arr_like_0p5)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_0p5, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(0.1, 0.5, 0.9)) # E: float reveal_type(random_st.triangular(0.1, 0.5, 0.9, size=None)) # E: float reveal_type(random_st.triangular(0.1, 0.5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_0p1, 0.5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(0.1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(0.1, D_arr_0p5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(0.5, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(0.1, 0.5, 0.9)) # E: float reveal_type(random_st.noncentral_f(0.1, 0.5, 0.9, size=None)) # E: float reveal_type(random_st.noncentral_f(0.1, 0.5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_0p1, 0.5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(0.1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.binomial(10, 0.5)) # E: int reveal_type(random_st.binomial(10, 0.5, size=None)) # E: int reveal_type(random_st.binomial(10, 0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_10, 0.5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(10, D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_10, 0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_like_10, 0.5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(10, D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_10, D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_like_10, D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(10, 0.5)) # E: int reveal_type(random_st.negative_binomial(10, 0.5, size=None)) # E: int reveal_type(random_st.negative_binomial(10, 0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_10, 0.5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(10, D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_10, 0.5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_like_10, 0.5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(10, D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_10, D_arr_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(20, 20, 10)) # E: int reveal_type(random_st.hypergeometric(20, 20, 10, size=None)) # E: int reveal_type(random_st.hypergeometric(20, 20, 10, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_20, 20, 10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(20, I_arr_20, 10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(20, I_arr_20, 10, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_like_20, 20, I_arr_10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(20, I_arr_like_20, 10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_20, I_arr_20, 10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.randint(0, 100)) # E: int reveal_type(random_st.randint(100)) # E: int reveal_type(random_st.randint([100])) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.randint(0, [100])) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.randint(2, dtype=bool)) # E: builtins.bool reveal_type(random_st.randint(0, 2, dtype=bool)) # E: builtins.bool reveal_type(random_st.randint(I_bool_high_open, dtype=bool)) # E: ndarray[Any, dtype[bool_] reveal_type(random_st.randint(I_bool_low, I_bool_high_open, dtype=bool)) # E: ndarray[Any, dtype[bool_] reveal_type(random_st.randint(0, I_bool_high_open, dtype=bool)) # E: ndarray[Any, dtype[bool_] reveal_type(random_st.randint(2, dtype=np.bool_)) # E: builtins.bool reveal_type(random_st.randint(0, 2, dtype=np.bool_)) # E: builtins.bool reveal_type(random_st.randint(I_bool_high_open, dtype=np.bool_)) # E: ndarray[Any, dtype[bool_] reveal_type(random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool_)) # E: ndarray[Any, dtype[bool_] reveal_type(random_st.randint(0, I_bool_high_open, dtype=np.bool_)) # E: ndarray[Any, dtype[bool_] reveal_type(random_st.randint(256, dtype="u1")) # E: int reveal_type(random_st.randint(0, 256, dtype="u1")) # E: int reveal_type(random_st.randint(I_u1_high_open, dtype="u1")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(I_u1_low, I_u1_high_open, dtype="u1")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(0, I_u1_high_open, dtype="u1")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(256, dtype="uint8")) # E: int reveal_type(random_st.randint(0, 256, dtype="uint8")) # E: int reveal_type(random_st.randint(I_u1_high_open, dtype="uint8")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(0, I_u1_high_open, dtype="uint8")) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(256, dtype=np.uint8)) # E: int reveal_type(random_st.randint(0, 256, dtype=np.uint8)) # E: int reveal_type(random_st.randint(I_u1_high_open, dtype=np.uint8)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(0, I_u1_high_open, dtype=np.uint8)) # E: ndarray[Any, dtype[unsignedinteger[typing._8Bit]]] reveal_type(random_st.randint(65536, dtype="u2")) # E: int reveal_type(random_st.randint(0, 65536, dtype="u2")) # E: int reveal_type(random_st.randint(I_u2_high_open, dtype="u2")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(I_u2_low, I_u2_high_open, dtype="u2")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(0, I_u2_high_open, dtype="u2")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(65536, dtype="uint16")) # E: int reveal_type(random_st.randint(0, 65536, dtype="uint16")) # E: int reveal_type(random_st.randint(I_u2_high_open, dtype="uint16")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(0, I_u2_high_open, dtype="uint16")) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(65536, dtype=np.uint16)) # E: int reveal_type(random_st.randint(0, 65536, dtype=np.uint16)) # E: int reveal_type(random_st.randint(I_u2_high_open, dtype=np.uint16)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(0, I_u2_high_open, dtype=np.uint16)) # E: ndarray[Any, dtype[unsignedinteger[typing._16Bit]]] reveal_type(random_st.randint(4294967296, dtype="u4")) # E: int reveal_type(random_st.randint(0, 4294967296, dtype="u4")) # E: int reveal_type(random_st.randint(I_u4_high_open, dtype="u4")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype="u4")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(0, I_u4_high_open, dtype="u4")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(4294967296, dtype="uint32")) # E: int reveal_type(random_st.randint(0, 4294967296, dtype="uint32")) # E: int reveal_type(random_st.randint(I_u4_high_open, dtype="uint32")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(0, I_u4_high_open, dtype="uint32")) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(4294967296, dtype=np.uint32)) # E: int reveal_type(random_st.randint(0, 4294967296, dtype=np.uint32)) # E: int reveal_type(random_st.randint(I_u4_high_open, dtype=np.uint32)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(0, I_u4_high_open, dtype=np.uint32)) # E: ndarray[Any, dtype[unsignedinteger[typing._32Bit]]] reveal_type(random_st.randint(4294967296, dtype=np.uint)) # E: int reveal_type(random_st.randint(0, 4294967296, dtype=np.uint)) # E: int reveal_type(random_st.randint(I_u4_high_open, dtype=np.uint)) # E: ndarray[Any, dtype[{uint}]] reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint)) # E: ndarray[Any, dtype[{uint}]] reveal_type(random_st.randint(0, I_u4_high_open, dtype=np.uint)) # E: ndarray[Any, dtype[{uint}]] reveal_type(random_st.randint(18446744073709551616, dtype="u8")) # E: int reveal_type(random_st.randint(0, 18446744073709551616, dtype="u8")) # E: int reveal_type(random_st.randint(I_u8_high_open, dtype="u8")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(I_u8_low, I_u8_high_open, dtype="u8")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(0, I_u8_high_open, dtype="u8")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(18446744073709551616, dtype="uint64")) # E: int reveal_type(random_st.randint(0, 18446744073709551616, dtype="uint64")) # E: int reveal_type(random_st.randint(I_u8_high_open, dtype="uint64")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(0, I_u8_high_open, dtype="uint64")) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(18446744073709551616, dtype=np.uint64)) # E: int reveal_type(random_st.randint(0, 18446744073709551616, dtype=np.uint64)) # E: int reveal_type(random_st.randint(I_u8_high_open, dtype=np.uint64)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(0, I_u8_high_open, dtype=np.uint64)) # E: ndarray[Any, dtype[unsignedinteger[typing._64Bit]]] reveal_type(random_st.randint(128, dtype="i1")) # E: int reveal_type(random_st.randint(-128, 128, dtype="i1")) # E: int reveal_type(random_st.randint(I_i1_high_open, dtype="i1")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(I_i1_low, I_i1_high_open, dtype="i1")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(-128, I_i1_high_open, dtype="i1")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(128, dtype="int8")) # E: int reveal_type(random_st.randint(-128, 128, dtype="int8")) # E: int reveal_type(random_st.randint(I_i1_high_open, dtype="int8")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(I_i1_low, I_i1_high_open, dtype="int8")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(-128, I_i1_high_open, dtype="int8")) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(128, dtype=np.int8)) # E: int reveal_type(random_st.randint(-128, 128, dtype=np.int8)) # E: int reveal_type(random_st.randint(I_i1_high_open, dtype=np.int8)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(-128, I_i1_high_open, dtype=np.int8)) # E: ndarray[Any, dtype[signedinteger[typing._8Bit]]] reveal_type(random_st.randint(32768, dtype="i2")) # E: int reveal_type(random_st.randint(-32768, 32768, dtype="i2")) # E: int reveal_type(random_st.randint(I_i2_high_open, dtype="i2")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(I_i2_low, I_i2_high_open, dtype="i2")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(-32768, I_i2_high_open, dtype="i2")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(32768, dtype="int16")) # E: int reveal_type(random_st.randint(-32768, 32768, dtype="int16")) # E: int reveal_type(random_st.randint(I_i2_high_open, dtype="int16")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(I_i2_low, I_i2_high_open, dtype="int16")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(-32768, I_i2_high_open, dtype="int16")) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(32768, dtype=np.int16)) # E: int reveal_type(random_st.randint(-32768, 32768, dtype=np.int16)) # E: int reveal_type(random_st.randint(I_i2_high_open, dtype=np.int16)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(-32768, I_i2_high_open, dtype=np.int16)) # E: ndarray[Any, dtype[signedinteger[typing._16Bit]]] reveal_type(random_st.randint(2147483648, dtype="i4")) # E: int reveal_type(random_st.randint(-2147483648, 2147483648, dtype="i4")) # E: int reveal_type(random_st.randint(I_i4_high_open, dtype="i4")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype="i4")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype="i4")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(2147483648, dtype="int32")) # E: int reveal_type(random_st.randint(-2147483648, 2147483648, dtype="int32")) # E: int reveal_type(random_st.randint(I_i4_high_open, dtype="int32")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype="int32")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype="int32")) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(2147483648, dtype=np.int32)) # E: int reveal_type(random_st.randint(-2147483648, 2147483648, dtype=np.int32)) # E: int reveal_type(random_st.randint(I_i4_high_open, dtype=np.int32)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32)) # E: ndarray[Any, dtype[signedinteger[typing._32Bit]]] reveal_type(random_st.randint(2147483648, dtype=np.int_)) # E: int reveal_type(random_st.randint(-2147483648, 2147483648, dtype=np.int_)) # E: int reveal_type(random_st.randint(I_i4_high_open, dtype=np.int_)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int_)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype=np.int_)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.randint(9223372036854775808, dtype="i8")) # E: int reveal_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8")) # E: int reveal_type(random_st.randint(I_i8_high_open, dtype="i8")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(I_i8_low, I_i8_high_open, dtype="i8")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(9223372036854775808, dtype="int64")) # E: int reveal_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64")) # E: int reveal_type(random_st.randint(I_i8_high_open, dtype="int64")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(I_i8_low, I_i8_high_open, dtype="int64")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64")) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(9223372036854775808, dtype=np.int64)) # E: int reveal_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64)) # E: int reveal_type(random_st.randint(I_i8_high_open, dtype=np.int64)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64)) # E: ndarray[Any, dtype[signedinteger[typing._64Bit]]] reveal_type(random_st._bit_generator) # E: BitGenerator reveal_type(random_st.bytes(2)) # E: bytes reveal_type(random_st.choice(5)) # E: int reveal_type(random_st.choice(5, 3)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.choice(5, 3, replace=True)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.choice(5, 3, p=[1 / 5] * 5)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.choice(5, 3, p=[1 / 5] * 5, replace=False)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"])) # E: Any reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)) # E: ndarray[Any, Any] reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)) # E: ndarray[Any, Any] reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)) # E: ndarray[Any, Any] reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))) # E: ndarray[Any, Any] reveal_type(random_st.dirichlet([0.5, 0.5])) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.dirichlet(np.array([0.5, 0.5]))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.dirichlet(np.array([0.5, 0.5]), size=3)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.multinomial(20, [1 / 6.0] * 6)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.multinomial(20, np.array([0.5, 0.5]))) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.multinomial(20, [1 / 6.0] * 6, size=2)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.multivariate_normal([0.0], [[1.0]])) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.multivariate_normal([0.0], np.array([[1.0]]))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.multivariate_normal(np.array([0.0]), [[1.0]])) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.multivariate_normal([0.0], np.array([[1.0]]))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.permutation(10)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.permutation([1, 2, 3, 4])) # E: ndarray[Any, Any] reveal_type(random_st.permutation(np.array([1, 2, 3, 4]))) # E: ndarray[Any, Any] reveal_type(random_st.permutation(D_2D)) # E: ndarray[Any, Any] reveal_type(random_st.shuffle(np.arange(10))) # E: None reveal_type(random_st.shuffle([1, 2, 3, 4, 5])) # E: None reveal_type(random_st.shuffle(D_2D)) # E: None reveal_type(np.random.RandomState(pcg64)) # E: RandomState reveal_type(np.random.RandomState(0)) # E: RandomState reveal_type(np.random.RandomState([0, 1, 2])) # E: RandomState reveal_type(random_st.__str__()) # E: str reveal_type(random_st.__repr__()) # E: str random_st_state = random_st.__getstate__() reveal_type(random_st_state) # E: builtins.dict[builtins.str, Any] reveal_type(random_st.__setstate__(random_st_state)) # E: None reveal_type(random_st.seed()) # E: None reveal_type(random_st.seed(1)) # E: None reveal_type(random_st.seed([0, 1])) # E: None random_st_get_state = random_st.get_state() reveal_type(random_st_state) # E: builtins.dict[builtins.str, Any] random_st_get_state_legacy = random_st.get_state(legacy=True) reveal_type(random_st_get_state_legacy) # E: Union[builtins.dict[builtins.str, Any], Tuple[builtins.str, ndarray[Any, dtype[unsignedinteger[typing._32Bit]]], builtins.int, builtins.int, builtins.float]] reveal_type(random_st.set_state(random_st_get_state)) # E: None reveal_type(random_st.rand()) # E: float reveal_type(random_st.rand(1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.rand(1, 2)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.randn()) # E: float reveal_type(random_st.randn(1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.randn(1, 2)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.random_sample()) # E: float reveal_type(random_st.random_sample(1)) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.random_sample(size=(1, 2))) # E: ndarray[Any, dtype[floating[typing._64Bit]] reveal_type(random_st.tomaxint()) # E: int reveal_type(random_st.tomaxint(1)) # E: ndarray[Any, dtype[{int_}]] reveal_type(random_st.tomaxint((1,))) # E: ndarray[Any, dtype[{int_}]] reveal_type(np.random.set_bit_generator(pcg64)) # E: None reveal_type(np.random.get_bit_generator()) # E: BitGenerator PKIZZ/4 4 data/reveal/rec.pyinu[import io from typing import Any import numpy as np import numpy.typing as npt AR_i8: npt.NDArray[np.int64] REC_AR_V: np.recarray[Any, np.dtype[np.record]] AR_LIST: list[npt.NDArray[np.int64]] format_parser: np.format_parser record: np.record file_obj: io.BufferedIOBase reveal_type(np.format_parser( # E: format_parser formats=[np.float64, np.int64, np.bool_], names=["f8", "i8", "?"], titles=None, aligned=True, )) reveal_type(format_parser.dtype) # E: dtype[void] reveal_type(record.field_a) # E: Any reveal_type(record.field_b) # E: Any reveal_type(record["field_a"]) # E: Any reveal_type(record["field_b"]) # E: Any reveal_type(record.pprint()) # E: str record.field_c = 5 reveal_type(REC_AR_V.field(0)) # E: Any reveal_type(REC_AR_V.field("field_a")) # E: Any reveal_type(REC_AR_V.field(0, AR_i8)) # E: None reveal_type(REC_AR_V.field("field_a", AR_i8)) # E: None reveal_type(REC_AR_V["field_a"]) # E: Any reveal_type(REC_AR_V.field_a) # E: Any reveal_type(REC_AR_V.__array_finalize__(object())) # E: None reveal_type(np.recarray( # recarray[Any, dtype[record]] shape=(10, 5), formats=[np.float64, np.int64, np.bool_], order="K", byteorder="|", )) reveal_type(np.recarray( # recarray[Any, dtype[Any]] shape=(10, 5), dtype=[("f8", np.float64), ("i8", np.int64)], strides=(5, 5), )) reveal_type(np.rec.fromarrays( # recarray[Any, dtype[record]] AR_LIST, )) reveal_type(np.rec.fromarrays( # recarray[Any, dtype[Any]] AR_LIST, dtype=np.int64, )) reveal_type(np.rec.fromarrays( # recarray[Any, dtype[Any]] AR_LIST, formats=[np.int64, np.float64], names=["i8", "f8"] )) reveal_type(np.rec.fromrecords( # recarray[Any, dtype[record]] (1, 1.5), )) reveal_type(np.rec.fromrecords( # recarray[Any, dtype[record]] [(1, 1.5)], dtype=[("i8", np.int64), ("f8", np.float64)], )) reveal_type(np.rec.fromrecords( # recarray[Any, dtype[record]] REC_AR_V, formats=[np.int64, np.float64], names=["i8", "f8"] )) reveal_type(np.rec.fromstring( # recarray[Any, dtype[record]] b"(1, 1.5)", dtype=[("i8", np.int64), ("f8", np.float64)], )) reveal_type(np.rec.fromstring( # recarray[Any, dtype[record]] REC_AR_V, formats=[np.int64, np.float64], names=["i8", "f8"] )) reveal_type(np.rec.fromfile( # recarray[Any, dtype[Any]] "test_file.txt", dtype=[("i8", np.int64), ("f8", np.float64)], )) reveal_type(np.rec.fromfile( # recarray[Any, dtype[record]] file_obj, formats=[np.int64, np.float64], names=["i8", "f8"] )) reveal_type(np.rec.array( # recarray[Any, dtype[{int64}]] AR_i8, )) reveal_type(np.rec.array( # recarray[Any, dtype[Any]] [(1, 1.5)], dtype=[("i8", np.int64), ("f8", np.float64)], )) reveal_type(np.rec.array( # recarray[Any, dtype[record]] [(1, 1.5)], formats=[np.int64, np.float64], names=["i8", "f8"] )) reveal_type(np.rec.array( # recarray[Any, dtype[Any]] None, dtype=np.float64, shape=(10, 3), )) reveal_type(np.rec.array( # recarray[Any, dtype[Any]] None, formats=[np.int64, np.float64], names=["i8", "f8"], shape=(10, 3), )) reveal_type(np.rec.array( # recarray[Any, dtype[Any]] file_obj, dtype=np.float64, )) reveal_type(np.rec.array( # recarray[Any, dtype[Any]] file_obj, formats=[np.int64, np.float64], names=["i8", "f8"], )) PKIZ1 Hdata/reveal/scalars.pyinu[import numpy as np b: np.bool_ u8: np.uint64 i8: np.int64 f8: np.float64 c8: np.complex64 c16: np.complex128 m: np.timedelta64 U: np.str_ S: np.bytes_ V: np.void reveal_type(c8.real) # E: {float32} reveal_type(c8.imag) # E: {float32} reveal_type(c8.real.real) # E: {float32} reveal_type(c8.real.imag) # E: {float32} reveal_type(c8.itemsize) # E: int reveal_type(c8.shape) # E: Tuple[] reveal_type(c8.strides) # E: Tuple[] reveal_type(c8.ndim) # E: Literal[0] reveal_type(c8.size) # E: Literal[1] reveal_type(c8.squeeze()) # E: {complex64} reveal_type(c8.byteswap()) # E: {complex64} reveal_type(c8.transpose()) # E: {complex64} reveal_type(c8.dtype) # E: dtype[{complex64}] reveal_type(c8.real) # E: {float32} reveal_type(c16.imag) # E: {float64} reveal_type(np.unicode_('foo')) # E: str_ reveal_type(V[0]) # E: Any reveal_type(V["field1"]) # E: Any reveal_type(V[["field1", "field2"]]) # E: void V[0] = 5 # Aliases reveal_type(np.unicode_()) # E: str_ reveal_type(np.string_()) # E: bytes_ reveal_type(np.byte()) # E: {byte} reveal_type(np.short()) # E: {short} reveal_type(np.intc()) # E: {intc} reveal_type(np.intp()) # E: {intp} reveal_type(np.int_()) # E: {int_} reveal_type(np.longlong()) # E: {longlong} reveal_type(np.ubyte()) # E: {ubyte} reveal_type(np.ushort()) # E: {ushort} reveal_type(np.uintc()) # E: {uintc} reveal_type(np.uintp()) # E: {uintp} reveal_type(np.uint()) # E: {uint} reveal_type(np.ulonglong()) # E: {ulonglong} reveal_type(np.half()) # E: {half} reveal_type(np.single()) # E: {single} reveal_type(np.double()) # E: {double} reveal_type(np.float_()) # E: {double} reveal_type(np.longdouble()) # E: {longdouble} reveal_type(np.longfloat()) # E: {longdouble} reveal_type(np.csingle()) # E: {csingle} reveal_type(np.singlecomplex()) # E: {csingle} reveal_type(np.cdouble()) # E: {cdouble} reveal_type(np.complex_()) # E: {cdouble} reveal_type(np.cfloat()) # E: {cdouble} reveal_type(np.clongdouble()) # E: {clongdouble} reveal_type(np.clongfloat()) # E: {clongdouble} reveal_type(np.longcomplex()) # E: {clongdouble} reveal_type(b.item()) # E: bool reveal_type(i8.item()) # E: int reveal_type(u8.item()) # E: int reveal_type(f8.item()) # E: float reveal_type(c16.item()) # E: complex reveal_type(U.item()) # E: str reveal_type(S.item()) # E: bytes reveal_type(b.tolist()) # E: bool reveal_type(i8.tolist()) # E: int reveal_type(u8.tolist()) # E: int reveal_type(f8.tolist()) # E: float reveal_type(c16.tolist()) # E: complex reveal_type(U.tolist()) # E: str reveal_type(S.tolist()) # E: bytes reveal_type(b.ravel()) # E: ndarray[Any, dtype[bool_]] reveal_type(i8.ravel()) # E: ndarray[Any, dtype[{int64}]] reveal_type(u8.ravel()) # E: ndarray[Any, dtype[{uint64}]] reveal_type(f8.ravel()) # E: ndarray[Any, dtype[{float64}]] reveal_type(c16.ravel()) # E: ndarray[Any, dtype[{complex128}]] reveal_type(U.ravel()) # E: ndarray[Any, dtype[str_]] reveal_type(S.ravel()) # E: ndarray[Any, dtype[bytes_]] reveal_type(b.flatten()) # E: ndarray[Any, dtype[bool_]] reveal_type(i8.flatten()) # E: ndarray[Any, dtype[{int64}]] reveal_type(u8.flatten()) # E: ndarray[Any, dtype[{uint64}]] reveal_type(f8.flatten()) # E: ndarray[Any, dtype[{float64}]] reveal_type(c16.flatten()) # E: ndarray[Any, dtype[{complex128}]] reveal_type(U.flatten()) # E: ndarray[Any, dtype[str_]] reveal_type(S.flatten()) # E: ndarray[Any, dtype[bytes_]] reveal_type(b.reshape(1)) # E: ndarray[Any, dtype[bool_]] reveal_type(i8.reshape(1)) # E: ndarray[Any, dtype[{int64}]] reveal_type(u8.reshape(1)) # E: ndarray[Any, dtype[{uint64}]] reveal_type(f8.reshape(1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(c16.reshape(1)) # E: ndarray[Any, dtype[{complex128}]] reveal_type(U.reshape(1)) # E: ndarray[Any, dtype[str_]] reveal_type(S.reshape(1)) # E: ndarray[Any, dtype[bytes_]] reveal_type(i8.astype(float)) # E: Any reveal_type(i8.astype(np.float64)) # E: {float64} reveal_type(i8.view()) # E: {int64} reveal_type(i8.view(np.float64)) # E: {float64} reveal_type(i8.view(float)) # E: Any reveal_type(i8.view(np.float64, np.ndarray)) # E: {float64} reveal_type(i8.getfield(float)) # E: Any reveal_type(i8.getfield(np.float64)) # E: {float64} reveal_type(i8.getfield(np.float64, 8)) # E: {float64} reveal_type(f8.as_integer_ratio()) # E: Tuple[builtins.int, builtins.int] reveal_type(f8.is_integer()) # E: bool reveal_type(f8.__trunc__()) # E: int reveal_type(f8.__getformat__("float")) # E: str reveal_type(f8.hex()) # E: str reveal_type(np.float64.fromhex("0x0.0p+0")) # E: {float64} reveal_type(f8.__getnewargs__()) # E: Tuple[builtins.float] reveal_type(c16.__getnewargs__()) # E: Tuple[builtins.float, builtins.float] reveal_type(i8.numerator) # E: {int64} reveal_type(i8.denominator) # E: Literal[1] reveal_type(u8.numerator) # E: {uint64} reveal_type(u8.denominator) # E: Literal[1] reveal_type(m.numerator) # E: timedelta64 reveal_type(m.denominator) # E: Literal[1] reveal_type(round(i8)) # E: int reveal_type(round(i8, 3)) # E: {int64} reveal_type(round(u8)) # E: int reveal_type(round(u8, 3)) # E: {uint64} reveal_type(round(f8)) # E: int reveal_type(round(f8, 3)) # E: {float64} reveal_type(f8.__ceil__()) # E: int reveal_type(f8.__floor__()) # E: int reveal_type(i8.is_integer()) # E: Literal[True] PKIZjH H data/reveal/shape_base.pyinu[import numpy as np from numpy._typing import NDArray from typing import Any i8: np.int64 f8: np.float64 AR_b: NDArray[np.bool_] AR_i8: NDArray[np.int64] AR_f8: NDArray[np.float64] AR_LIKE_f8: list[float] reveal_type(np.take_along_axis(AR_f8, AR_i8, axis=1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.take_along_axis(f8, AR_i8, axis=None)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1)) # E: None reveal_type(np.expand_dims(AR_i8, 2)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.expand_dims(AR_LIKE_f8, 2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.column_stack([AR_i8])) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.column_stack([AR_LIKE_f8])) # E: ndarray[Any, dtype[Any]] reveal_type(np.dstack([AR_i8])) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.dstack([AR_LIKE_f8])) # E: ndarray[Any, dtype[Any]] reveal_type(np.row_stack([AR_i8])) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.row_stack([AR_LIKE_f8])) # E: ndarray[Any, dtype[Any]] reveal_type(np.array_split(AR_i8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[{int64}]]] reveal_type(np.array_split(AR_LIKE_f8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.split(AR_i8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[{int64}]]] reveal_type(np.split(AR_LIKE_f8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.hsplit(AR_i8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[{int64}]]] reveal_type(np.hsplit(AR_LIKE_f8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.vsplit(AR_i8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[{int64}]]] reveal_type(np.vsplit(AR_LIKE_f8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.dsplit(AR_i8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[{int64}]]] reveal_type(np.dsplit(AR_LIKE_f8, [3, 5, 6, 10])) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.lib.shape_base.get_array_prepare(AR_i8)) # E: lib.shape_base._ArrayPrepare reveal_type(np.lib.shape_base.get_array_prepare(AR_i8, 1)) # E: Union[None, lib.shape_base._ArrayPrepare] reveal_type(np.get_array_wrap(AR_i8)) # E: lib.shape_base._ArrayWrap reveal_type(np.get_array_wrap(AR_i8, 1)) # E: Union[None, lib.shape_base._ArrayWrap] reveal_type(np.kron(AR_b, AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.kron(AR_b, AR_i8)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.kron(AR_f8, AR_f8)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.tile(AR_i8, 5)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.tile(AR_LIKE_f8, [2, 2])) # E: ndarray[Any, dtype[Any]] PKIZwtdata/reveal/stride_tricks.pyinu[from typing import Any import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_LIKE_f: list[float] interface_dict: dict[str, Any] reveal_type(np.lib.stride_tricks.DummyArray(interface_dict)) # E: lib.stride_tricks.DummyArray reveal_type(np.lib.stride_tricks.as_strided(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.lib.stride_tricks.as_strided(AR_LIKE_f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.lib.stride_tricks.as_strided(AR_f8, strides=(1, 5))) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.lib.stride_tricks.as_strided(AR_f8, shape=[9, 20])) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.lib.stride_tricks.sliding_window_view(AR_f8, 5)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.lib.stride_tricks.sliding_window_view(AR_LIKE_f, (1, 5))) # E: ndarray[Any, dtype[Any]] reveal_type(np.lib.stride_tricks.sliding_window_view(AR_f8, [9], axis=1)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.broadcast_to(AR_f8, 5)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.broadcast_to(AR_LIKE_f, (1, 5))) # E: ndarray[Any, dtype[Any]] reveal_type(np.broadcast_to(AR_f8, [4, 6], subok=True)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.broadcast_shapes((1, 2), [3, 1], (3, 2))) # E: tuple[builtins.int, ...] reveal_type(np.broadcast_shapes((6, 7), (5, 6, 1), 7, (5, 1, 7))) # E: tuple[builtins.int, ...] reveal_type(np.broadcast_arrays(AR_f8, AR_f8)) # E: list[ndarray[Any, dtype[Any]]] reveal_type(np.broadcast_arrays(AR_f8, AR_LIKE_f)) # E: list[ndarray[Any, dtype[Any]]] PKIZ\""data/reveal/testing.pyinu[from __future__ import annotations import re import sys from collections.abc import Callable from typing import Any, TypeVar from pathlib import Path import numpy as np import numpy.typing as npt AR_f8: npt.NDArray[np.float64] AR_i8: npt.NDArray[np.int64] bool_obj: bool suppress_obj: np.testing.suppress_warnings FT = TypeVar("FT", bound=Callable[..., Any]) def func() -> int: ... def func2( x: npt.NDArray[np.number[Any]], y: npt.NDArray[np.number[Any]], ) -> npt.NDArray[np.bool_]: ... reveal_type(np.testing.KnownFailureException()) # E: KnownFailureException reveal_type(np.testing.IgnoreException()) # E: IgnoreException reveal_type(np.testing.clear_and_catch_warnings(modules=[np.testing])) # E: _clear_and_catch_warnings_without_records reveal_type(np.testing.clear_and_catch_warnings(True)) # E: _clear_and_catch_warnings_with_records reveal_type(np.testing.clear_and_catch_warnings(False)) # E: _clear_and_catch_warnings_without_records reveal_type(np.testing.clear_and_catch_warnings(bool_obj)) # E: clear_and_catch_warnings reveal_type(np.testing.clear_and_catch_warnings.class_modules) # E: tuple[types.ModuleType, ...] reveal_type(np.testing.clear_and_catch_warnings.modules) # E: set[types.ModuleType] with np.testing.clear_and_catch_warnings(True) as c1: reveal_type(c1) # E: builtins.list[warnings.WarningMessage] with np.testing.clear_and_catch_warnings() as c2: reveal_type(c2) # E: None reveal_type(np.testing.suppress_warnings("once")) # E: suppress_warnings reveal_type(np.testing.suppress_warnings()(func)) # E: def () -> builtins.int reveal_type(suppress_obj.filter(RuntimeWarning)) # E: None reveal_type(suppress_obj.record(RuntimeWarning)) # E: list[warnings.WarningMessage] with suppress_obj as c3: reveal_type(c3) # E: suppress_warnings reveal_type(np.testing.verbose) # E: int reveal_type(np.testing.IS_PYPY) # E: bool reveal_type(np.testing.HAS_REFCOUNT) # E: bool reveal_type(np.testing.HAS_LAPACK64) # E: bool reveal_type(np.testing.assert_(1, msg="test")) # E: None reveal_type(np.testing.assert_(2, msg=lambda: "test")) # E: None if sys.platform == "win32" or sys.platform == "cygwin": reveal_type(np.testing.memusage()) # E: builtins.int elif sys.platform == "linux": reveal_type(np.testing.memusage()) # E: Union[None, builtins.int] else: reveal_type(np.testing.memusage()) # E: reveal_type(np.testing.jiffies()) # E: builtins.int reveal_type(np.testing.build_err_msg([0, 1, 2], "test")) # E: str reveal_type(np.testing.build_err_msg(range(2), "test", header="header")) # E: str reveal_type(np.testing.build_err_msg(np.arange(9).reshape(3, 3), "test", verbose=False)) # E: str reveal_type(np.testing.build_err_msg("abc", "test", names=["x", "y"])) # E: str reveal_type(np.testing.build_err_msg([1.0, 2.0], "test", precision=5)) # E: str reveal_type(np.testing.assert_equal({1}, {1})) # E: None reveal_type(np.testing.assert_equal([1, 2, 3], [1, 2, 3], err_msg="fail")) # E: None reveal_type(np.testing.assert_equal(1, 1.0, verbose=True)) # E: None reveal_type(np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 1])) # E: None reveal_type(np.testing.assert_almost_equal(1.0, 1.1)) # E: None reveal_type(np.testing.assert_almost_equal([1, 2, 3], [1, 2, 3], err_msg="fail")) # E: None reveal_type(np.testing.assert_almost_equal(1, 1.0, verbose=True)) # E: None reveal_type(np.testing.assert_almost_equal(1, 1.0001, decimal=2)) # E: None reveal_type(np.testing.assert_approx_equal(1.0, 1.1)) # E: None reveal_type(np.testing.assert_approx_equal("1", "2", err_msg="fail")) # E: None reveal_type(np.testing.assert_approx_equal(1, 1.0, verbose=True)) # E: None reveal_type(np.testing.assert_approx_equal(1, 1.0001, significant=2)) # E: None reveal_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, err_msg="test")) # E: None reveal_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, verbose=True)) # E: None reveal_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, header="header")) # E: None reveal_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, precision=np.int64())) # E: None reveal_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, equal_nan=False)) # E: None reveal_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, equal_inf=True)) # E: None reveal_type(np.testing.assert_array_equal(AR_i8, AR_f8)) # E: None reveal_type(np.testing.assert_array_equal(AR_i8, AR_f8, err_msg="test")) # E: None reveal_type(np.testing.assert_array_equal(AR_i8, AR_f8, verbose=True)) # E: None reveal_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8)) # E: None reveal_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, err_msg="test")) # E: None reveal_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, verbose=True)) # E: None reveal_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, decimal=1)) # E: None reveal_type(np.testing.assert_array_less(AR_i8, AR_f8)) # E: None reveal_type(np.testing.assert_array_less(AR_i8, AR_f8, err_msg="test")) # E: None reveal_type(np.testing.assert_array_less(AR_i8, AR_f8, verbose=True)) # E: None reveal_type(np.testing.runstring("1 + 1", {})) # E: Any reveal_type(np.testing.runstring("int64() + 1", {"int64": np.int64})) # E: Any reveal_type(np.testing.assert_string_equal("1", "1")) # E: None reveal_type(np.testing.rundocs()) # E: None reveal_type(np.testing.rundocs("test.py")) # E: None reveal_type(np.testing.rundocs(Path("test.py"), raise_on_error=True)) # E: None def func3(a: int) -> bool: ... reveal_type(func3) # E: def (a: builtins.int) -> builtins.bool reveal_type(np.testing.assert_raises(RuntimeWarning)) # E: _AssertRaisesContext[builtins.RuntimeWarning] reveal_type(np.testing.assert_raises(RuntimeWarning, func3, 5)) # E: None reveal_type(np.testing.assert_raises_regex(RuntimeWarning, r"test")) # E: _AssertRaisesContext[builtins.RuntimeWarning] reveal_type(np.testing.assert_raises_regex(RuntimeWarning, b"test", func3, 5)) # E: None reveal_type(np.testing.assert_raises_regex(RuntimeWarning, re.compile(b"test"), func3, 5)) # E: None class Test: ... def decorate(a: FT) -> FT: return a reveal_type(np.testing.decorate_methods(Test, decorate)) # E: None reveal_type(np.testing.decorate_methods(Test, decorate, None)) # E: None reveal_type(np.testing.decorate_methods(Test, decorate, "test")) # E: None reveal_type(np.testing.decorate_methods(Test, decorate, b"test")) # E: None reveal_type(np.testing.decorate_methods(Test, decorate, re.compile("test"))) # E: None reveal_type(np.testing.measure("for i in range(1000): np.sqrt(i**2)")) # E: float reveal_type(np.testing.measure(b"for i in range(1000): np.sqrt(i**2)", times=5)) # E: float reveal_type(np.testing.assert_allclose(AR_i8, AR_f8)) # E: None reveal_type(np.testing.assert_allclose(AR_i8, AR_f8, rtol=0.005)) # E: None reveal_type(np.testing.assert_allclose(AR_i8, AR_f8, atol=1)) # E: None reveal_type(np.testing.assert_allclose(AR_i8, AR_f8, equal_nan=True)) # E: None reveal_type(np.testing.assert_allclose(AR_i8, AR_f8, err_msg="err")) # E: None reveal_type(np.testing.assert_allclose(AR_i8, AR_f8, verbose=False)) # E: None reveal_type(np.testing.assert_array_almost_equal_nulp(AR_i8, AR_f8, nulp=2)) # E: None reveal_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, maxulp=2)) # E: ndarray[Any, dtype[Any]] reveal_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, dtype=np.float32)) # E: ndarray[Any, dtype[Any]] reveal_type(np.testing.assert_warns(RuntimeWarning)) # E: _GeneratorContextManager[None] reveal_type(np.testing.assert_warns(RuntimeWarning, func3, 5)) # E: bool def func4(a: int, b: str) -> bool: ... reveal_type(np.testing.assert_no_warnings()) # E: _GeneratorContextManager[None] reveal_type(np.testing.assert_no_warnings(func3, 5)) # E: bool reveal_type(np.testing.assert_no_warnings(func4, a=1, b="test")) # E: bool reveal_type(np.testing.assert_no_warnings(func4, 1, "test")) # E: bool reveal_type(np.testing.tempdir("test_dir")) # E: _GeneratorContextManager[builtins.str] reveal_type(np.testing.tempdir(prefix=b"test")) # E: _GeneratorContextManager[builtins.bytes] reveal_type(np.testing.tempdir("test_dir", dir=Path("here"))) # E: _GeneratorContextManager[builtins.str] reveal_type(np.testing.temppath("test_dir", text=True)) # E: _GeneratorContextManager[builtins.str] reveal_type(np.testing.temppath(prefix=b"test")) # E: _GeneratorContextManager[builtins.bytes] reveal_type(np.testing.temppath("test_dir", dir=Path("here"))) # E: _GeneratorContextManager[builtins.str] reveal_type(np.testing.assert_no_gc_cycles()) # E: _GeneratorContextManager[None] reveal_type(np.testing.assert_no_gc_cycles(func3, 5)) # E: None reveal_type(np.testing.break_cycles()) # E: None reveal_type(np.testing.TestCase()) # E: unittest.case.TestCase PKIZ>| data/reveal/twodim_base.pyinu[from typing import Any, TypeVar import numpy as np import numpy.typing as npt _SCT = TypeVar("_SCT", bound=np.generic) def func1(ar: npt.NDArray[_SCT], a: int) -> npt.NDArray[_SCT]: pass def func2(ar: npt.NDArray[np.number[Any]], a: str) -> npt.NDArray[np.float64]: pass AR_b: npt.NDArray[np.bool_] AR_u: npt.NDArray[np.uint64] AR_i: npt.NDArray[np.int64] AR_f: npt.NDArray[np.float64] AR_c: npt.NDArray[np.complex128] AR_O: npt.NDArray[np.object_] AR_LIKE_b: list[bool] reveal_type(np.fliplr(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.fliplr(AR_LIKE_b)) # E: ndarray[Any, dtype[Any]] reveal_type(np.flipud(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.flipud(AR_LIKE_b)) # E: ndarray[Any, dtype[Any]] reveal_type(np.eye(10)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.eye(10, M=20, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.eye(10, k=2, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.diag(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.diag(AR_LIKE_b, k=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.diagflat(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.diagflat(AR_LIKE_b, k=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.tri(10)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.tri(10, M=20, dtype=np.int64)) # E: ndarray[Any, dtype[{int64}]] reveal_type(np.tri(10, k=2, dtype=int)) # E: ndarray[Any, dtype[Any]] reveal_type(np.tril(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.tril(AR_LIKE_b, k=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.triu(AR_b)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.triu(AR_LIKE_b, k=0)) # E: ndarray[Any, dtype[Any]] reveal_type(np.vander(AR_b)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.vander(AR_u)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.vander(AR_i, N=2)) # E: ndarray[Any, dtype[signedinteger[Any]]] reveal_type(np.vander(AR_f, increasing=True)) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.vander(AR_c)) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.vander(AR_O)) # E: ndarray[Any, dtype[object_]] reveal_type(np.histogram2d(AR_i, AR_b)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(np.histogram2d(AR_f, AR_f)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[floating[Any]]], ndarray[Any, dtype[floating[Any]]]] reveal_type(np.histogram2d(AR_f, AR_c, weights=AR_LIKE_b)) # E: Tuple[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[complexfloating[Any, Any]]], ndarray[Any, dtype[complexfloating[Any, Any]]]] reveal_type(np.mask_indices(10, func1)) # E: Tuple[ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.mask_indices(8, func2, "0")) # E: Tuple[ndarray[Any, dtype[{intp}]], ndarray[Any, dtype[{intp}]]] reveal_type(np.tril_indices(10)) # E: Tuple[ndarray[Any, dtype[{int_}]], ndarray[Any, dtype[{int_}]]] reveal_type(np.tril_indices_from(AR_b)) # E: Tuple[ndarray[Any, dtype[{int_}]], ndarray[Any, dtype[{int_}]]] reveal_type(np.triu_indices(10)) # E: Tuple[ndarray[Any, dtype[{int_}]], ndarray[Any, dtype[{int_}]]] reveal_type(np.triu_indices_from(AR_b)) # E: Tuple[ndarray[Any, dtype[{int_}]], ndarray[Any, dtype[{int_}]]] PKIZQe5: data/reveal/type_check.pyinu[import numpy as np import numpy.typing as npt from numpy._typing import _128Bit f8: np.float64 f: float # NOTE: Avoid importing the platform specific `np.float128` type AR_i8: npt.NDArray[np.int64] AR_i4: npt.NDArray[np.int32] AR_f2: npt.NDArray[np.float16] AR_f8: npt.NDArray[np.float64] AR_f16: npt.NDArray[np.floating[_128Bit]] AR_c8: npt.NDArray[np.complex64] AR_c16: npt.NDArray[np.complex128] AR_LIKE_f: list[float] class RealObj: real: slice class ImagObj: imag: slice reveal_type(np.mintypecode(["f8"], typeset="qfQF")) reveal_type(np.asfarray(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asfarray(AR_LIKE_f)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.asfarray(AR_f8, dtype="c16")) # E: ndarray[Any, dtype[complexfloating[Any, Any]]] reveal_type(np.asfarray(AR_f8, dtype="i8")) # E: ndarray[Any, dtype[floating[Any]]] reveal_type(np.real(RealObj())) # E: slice reveal_type(np.real(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.real(AR_c16)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.real(AR_LIKE_f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.imag(ImagObj())) # E: slice reveal_type(np.imag(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.imag(AR_c16)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.imag(AR_LIKE_f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.iscomplex(f8)) # E: bool_ reveal_type(np.iscomplex(AR_f8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.iscomplex(AR_LIKE_f)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isreal(f8)) # E: bool_ reveal_type(np.isreal(AR_f8)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.isreal(AR_LIKE_f)) # E: ndarray[Any, dtype[bool_]] reveal_type(np.iscomplexobj(f8)) # E: bool reveal_type(np.isrealobj(f8)) # E: bool reveal_type(np.nan_to_num(f8)) # E: {float64} reveal_type(np.nan_to_num(f, copy=True)) # E: Any reveal_type(np.nan_to_num(AR_f8, nan=1.5)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.nan_to_num(AR_LIKE_f, posinf=9999)) # E: ndarray[Any, dtype[Any]] reveal_type(np.real_if_close(AR_f8)) # E: ndarray[Any, dtype[{float64}]] reveal_type(np.real_if_close(AR_c16)) # E: Union[ndarray[Any, dtype[{float64}]], ndarray[Any, dtype[{complex128}]]] reveal_type(np.real_if_close(AR_c8)) # E: Union[ndarray[Any, dtype[{float32}]], ndarray[Any, dtype[{complex64}]]] reveal_type(np.real_if_close(AR_LIKE_f)) # E: ndarray[Any, dtype[Any]] reveal_type(np.typename("h")) # E: Literal['short'] reveal_type(np.typename("B")) # E: Literal['unsigned char'] reveal_type(np.typename("V")) # E: Literal['void'] reveal_type(np.typename("S1")) # E: Literal['character'] reveal_type(np.common_type(AR_i4)) # E: Type[{float64}] reveal_type(np.common_type(AR_f2)) # E: Type[{float16}] reveal_type(np.common_type(AR_f2, AR_i4)) # E: Type[{float64}] reveal_type(np.common_type(AR_f16, AR_i4)) # E: Type[{float128}] reveal_type(np.common_type(AR_c8, AR_f2)) # E: Type[{complex64}] reveal_type(np.common_type(AR_f2, AR_c8, AR_i4)) # E: Type[{complex128}] PKIZ)data/reveal/ufunc_config.pyinu["""Typing tests for `core._ufunc_config`.""" import numpy as np def func(a: str, b: int) -> None: ... class Write: def write(self, value: str) -> None: ... reveal_type(np.seterr(all=None)) # E: TypedDict('core._ufunc_config._ErrDict' reveal_type(np.seterr(divide="ignore")) # E: TypedDict('core._ufunc_config._ErrDict' reveal_type(np.seterr(over="warn")) # E: TypedDict('core._ufunc_config._ErrDict' reveal_type(np.seterr(under="call")) # E: TypedDict('core._ufunc_config._ErrDict' reveal_type(np.seterr(invalid="raise")) # E: TypedDict('core._ufunc_config._ErrDict' reveal_type(np.geterr()) # E: TypedDict('core._ufunc_config._ErrDict' reveal_type(np.setbufsize(4096)) # E: int reveal_type(np.getbufsize()) # E: int reveal_type(np.seterrcall(func)) # E: Union[None, def (builtins.str, builtins.int) -> Any, _SupportsWrite[builtins.str]] reveal_type(np.seterrcall(Write())) # E: Union[None, def (builtins.str, builtins.int) -> Any, _SupportsWrite[builtins.str]] reveal_type(np.geterrcall()) # E: Union[None, def (builtins.str, builtins.int) -> Any, _SupportsWrite[builtins.str]] reveal_type(np.errstate(call=func, all="call")) # E: errstate[def (a: builtins.str, b: builtins.int)] reveal_type(np.errstate(call=Write(), divide="log", over="log")) # E: errstate[ufunc_config.Write] PKIZ_,,test_isfile.pynu[import os from pathlib import Path import numpy as np from numpy.testing import assert_ ROOT = Path(np.__file__).parents[0] FILES = [ ROOT / "py.typed", ROOT / "__init__.pyi", ROOT / "ctypeslib.pyi", ROOT / "core" / "__init__.pyi", ROOT / "distutils" / "__init__.pyi", ROOT / "f2py" / "__init__.pyi", ROOT / "fft" / "__init__.pyi", ROOT / "lib" / "__init__.pyi", ROOT / "linalg" / "__init__.pyi", ROOT / "ma" / "__init__.pyi", ROOT / "matrixlib" / "__init__.pyi", ROOT / "polynomial" / "__init__.pyi", ROOT / "random" / "__init__.pyi", ROOT / "testing" / "__init__.pyi", ] class TestIsFile: def test_isfile(self): """Test if all ``.pyi`` files are properly installed.""" for file in FILES: assert_(os.path.isfile(file)) PKIZ|h test_runtime.pynu["""Test the runtime usage of `numpy.typing`.""" from __future__ import annotations from typing import ( get_type_hints, Union, NamedTuple, get_args, get_origin, Any, ) import pytest import numpy as np import numpy.typing as npt import numpy._typing as _npt class TypeTup(NamedTuple): typ: type args: tuple[type, ...] origin: None | type NDArrayTup = TypeTup(npt.NDArray, npt.NDArray.__args__, np.ndarray) TYPES = { "ArrayLike": TypeTup(npt.ArrayLike, npt.ArrayLike.__args__, Union), "DTypeLike": TypeTup(npt.DTypeLike, npt.DTypeLike.__args__, Union), "NBitBase": TypeTup(npt.NBitBase, (), None), "NDArray": NDArrayTup, } @pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys()) def test_get_args(name: type, tup: TypeTup) -> None: """Test `typing.get_args`.""" typ, ref = tup.typ, tup.args out = get_args(typ) assert out == ref @pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys()) def test_get_origin(name: type, tup: TypeTup) -> None: """Test `typing.get_origin`.""" typ, ref = tup.typ, tup.origin out = get_origin(typ) assert out == ref @pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys()) def test_get_type_hints(name: type, tup: TypeTup) -> None: """Test `typing.get_type_hints`.""" typ = tup.typ # Explicitly set `__annotations__` in order to circumvent the # stringification performed by `from __future__ import annotations` def func(a): pass func.__annotations__ = {"a": typ, "return": None} out = get_type_hints(func) ref = {"a": typ, "return": type(None)} assert out == ref @pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys()) def test_get_type_hints_str(name: type, tup: TypeTup) -> None: """Test `typing.get_type_hints` with string-representation of types.""" typ_str, typ = f"npt.{name}", tup.typ # Explicitly set `__annotations__` in order to circumvent the # stringification performed by `from __future__ import annotations` def func(a): pass func.__annotations__ = {"a": typ_str, "return": None} out = get_type_hints(func) ref = {"a": typ, "return": type(None)} assert out == ref def test_keys() -> None: """Test that ``TYPES.keys()`` and ``numpy.typing.__all__`` are synced.""" keys = TYPES.keys() ref = set(npt.__all__) assert keys == ref PROTOCOLS: dict[str, tuple[type[Any], object]] = { "_SupportsDType": (_npt._SupportsDType, np.int64(1)), "_SupportsArray": (_npt._SupportsArray, np.arange(10)), "_SupportsArrayFunc": (_npt._SupportsArrayFunc, np.arange(10)), "_NestedSequence": (_npt._NestedSequence, [1]), } @pytest.mark.parametrize("cls,obj", PROTOCOLS.values(), ids=PROTOCOLS.keys()) class TestRuntimeProtocol: def test_isinstance(self, cls: type[Any], obj: object) -> None: assert isinstance(obj, cls) assert not isinstance(None, cls) def test_issubclass(self, cls: type[Any], obj: object) -> None: if cls is _npt._SupportsDType: pytest.xfail( "Protocols with non-method members don't support issubclass()" ) assert issubclass(type(obj), cls) assert not issubclass(type(None), cls) PKIZy;;test_typing.pynu[from __future__ import annotations import importlib.util import itertools import os import re import shutil from collections import defaultdict from collections.abc import Iterator from typing import IO, TYPE_CHECKING import pytest import numpy as np import numpy.typing as npt from numpy.typing.mypy_plugin import ( _PRECISION_DICT, _EXTENDED_PRECISION_LIST, _C_INTP, ) try: from mypy import api except ImportError: NO_MYPY = True else: NO_MYPY = False if TYPE_CHECKING: # We need this as annotation, but it's located in a private namespace. # As a compromise, do *not* import it during runtime from _pytest.mark.structures import ParameterSet DATA_DIR = os.path.join(os.path.dirname(__file__), "data") PASS_DIR = os.path.join(DATA_DIR, "pass") FAIL_DIR = os.path.join(DATA_DIR, "fail") REVEAL_DIR = os.path.join(DATA_DIR, "reveal") MISC_DIR = os.path.join(DATA_DIR, "misc") MYPY_INI = os.path.join(DATA_DIR, "mypy.ini") CACHE_DIR = os.path.join(DATA_DIR, ".mypy_cache") #: A dictionary with file names as keys and lists of the mypy stdout as values. #: To-be populated by `run_mypy`. OUTPUT_MYPY: dict[str, list[str]] = {} def _key_func(key: str) -> str: """Split at the first occurrence of the ``:`` character. Windows drive-letters (*e.g.* ``C:``) are ignored herein. """ drive, tail = os.path.splitdrive(key) return os.path.join(drive, tail.split(":", 1)[0]) def _strip_filename(msg: str) -> str: """Strip the filename from a mypy message.""" _, tail = os.path.splitdrive(msg) return tail.split(":", 1)[-1] def strip_func(match: re.Match[str]) -> str: """`re.sub` helper function for stripping module names.""" return match.groups()[1] @pytest.mark.slow @pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed") @pytest.fixture(scope="module", autouse=True) def run_mypy() -> None: """Clears the cache and run mypy before running any of the typing tests. The mypy results are cached in `OUTPUT_MYPY` for further use. The cache refresh can be skipped using NUMPY_TYPING_TEST_CLEAR_CACHE=0 pytest numpy/typing/tests """ if ( os.path.isdir(CACHE_DIR) and bool(os.environ.get("NUMPY_TYPING_TEST_CLEAR_CACHE", True)) ): shutil.rmtree(CACHE_DIR) for directory in (PASS_DIR, REVEAL_DIR, FAIL_DIR, MISC_DIR): # Run mypy stdout, stderr, exit_code = api.run([ "--config-file", MYPY_INI, "--cache-dir", CACHE_DIR, directory, ]) if stderr: pytest.fail(f"Unexpected mypy standard error\n\n{stderr}") elif exit_code not in {0, 1}: pytest.fail(f"Unexpected mypy exit code: {exit_code}\n\n{stdout}") stdout = stdout.replace('*', '') # Parse the output iterator = itertools.groupby(stdout.split("\n"), key=_key_func) OUTPUT_MYPY.update((k, list(v)) for k, v in iterator if k) def get_test_cases(directory: str) -> Iterator[ParameterSet]: for root, _, files in os.walk(directory): for fname in files: short_fname, ext = os.path.splitext(fname) if ext in (".pyi", ".py"): fullpath = os.path.join(root, fname) yield pytest.param(fullpath, id=short_fname) @pytest.mark.slow @pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed") @pytest.mark.parametrize("path", get_test_cases(PASS_DIR)) def test_success(path) -> None: # Alias `OUTPUT_MYPY` so that it appears in the local namespace output_mypy = OUTPUT_MYPY if path in output_mypy: msg = "Unexpected mypy output\n\n" msg += "\n".join(_strip_filename(v) for v in output_mypy[path]) raise AssertionError(msg) @pytest.mark.slow @pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed") @pytest.mark.parametrize("path", get_test_cases(FAIL_DIR)) def test_fail(path: str) -> None: __tracebackhide__ = True with open(path) as fin: lines = fin.readlines() errors = defaultdict(lambda: "") output_mypy = OUTPUT_MYPY assert path in output_mypy for error_line in output_mypy[path]: error_line = _strip_filename(error_line).split("\n", 1)[0] match = re.match( r"(?P\d+): (error|note): .+$", error_line, ) if match is None: raise ValueError(f"Unexpected error line format: {error_line}") lineno = int(match.group('lineno')) errors[lineno] += f'{error_line}\n' for i, line in enumerate(lines): lineno = i + 1 if ( line.startswith('#') or (" E:" not in line and lineno not in errors) ): continue target_line = lines[lineno - 1] if "# E:" in target_line: expression, _, marker = target_line.partition(" # E: ") expected_error = errors[lineno].strip() marker = marker.strip() _test_fail(path, expression, marker, expected_error, lineno) else: pytest.fail( f"Unexpected mypy output at line {lineno}\n\n{errors[lineno]}" ) _FAIL_MSG1 = """Extra error at line {} Expression: {} Extra error: {!r} """ _FAIL_MSG2 = """Error mismatch at line {} Expression: {} Expected error: {!r} Observed error: {!r} """ def _test_fail( path: str, expression: str, error: str, expected_error: None | str, lineno: int, ) -> None: if expected_error is None: raise AssertionError(_FAIL_MSG1.format(lineno, expression, error)) elif error not in expected_error: raise AssertionError(_FAIL_MSG2.format( lineno, expression, expected_error, error )) def _construct_ctypes_dict() -> dict[str, str]: dct = { "ubyte": "c_ubyte", "ushort": "c_ushort", "uintc": "c_uint", "uint": "c_ulong", "ulonglong": "c_ulonglong", "byte": "c_byte", "short": "c_short", "intc": "c_int", "int_": "c_long", "longlong": "c_longlong", "single": "c_float", "double": "c_double", "longdouble": "c_longdouble", } # Match `ctypes` names to the first ctypes type with a given kind and # precision, e.g. {"c_double": "c_double", "c_longdouble": "c_double"} # if both types represent 64-bit floats. # In this context "first" is defined by the order of `dct` ret = {} visited: dict[tuple[str, int], str] = {} for np_name, ct_name in dct.items(): np_scalar = getattr(np, np_name)() # Find the first `ctypes` type for a given `kind`/`itemsize` combo key = (np_scalar.dtype.kind, np_scalar.dtype.itemsize) ret[ct_name] = visited.setdefault(key, f"ctypes.{ct_name}") return ret def _construct_format_dict() -> dict[str, str]: dct = {k.split(".")[-1]: v.replace("numpy", "numpy._typing") for k, v in _PRECISION_DICT.items()} return { "uint8": "numpy.unsignedinteger[numpy._typing._8Bit]", "uint16": "numpy.unsignedinteger[numpy._typing._16Bit]", "uint32": "numpy.unsignedinteger[numpy._typing._32Bit]", "uint64": "numpy.unsignedinteger[numpy._typing._64Bit]", "uint128": "numpy.unsignedinteger[numpy._typing._128Bit]", "uint256": "numpy.unsignedinteger[numpy._typing._256Bit]", "int8": "numpy.signedinteger[numpy._typing._8Bit]", "int16": "numpy.signedinteger[numpy._typing._16Bit]", "int32": "numpy.signedinteger[numpy._typing._32Bit]", "int64": "numpy.signedinteger[numpy._typing._64Bit]", "int128": "numpy.signedinteger[numpy._typing._128Bit]", "int256": "numpy.signedinteger[numpy._typing._256Bit]", "float16": "numpy.floating[numpy._typing._16Bit]", "float32": "numpy.floating[numpy._typing._32Bit]", "float64": "numpy.floating[numpy._typing._64Bit]", "float80": "numpy.floating[numpy._typing._80Bit]", "float96": "numpy.floating[numpy._typing._96Bit]", "float128": "numpy.floating[numpy._typing._128Bit]", "float256": "numpy.floating[numpy._typing._256Bit]", "complex64": ("numpy.complexfloating" "[numpy._typing._32Bit, numpy._typing._32Bit]"), "complex128": ("numpy.complexfloating" "[numpy._typing._64Bit, numpy._typing._64Bit]"), "complex160": ("numpy.complexfloating" "[numpy._typing._80Bit, numpy._typing._80Bit]"), "complex192": ("numpy.complexfloating" "[numpy._typing._96Bit, numpy._typing._96Bit]"), "complex256": ("numpy.complexfloating" "[numpy._typing._128Bit, numpy._typing._128Bit]"), "complex512": ("numpy.complexfloating" "[numpy._typing._256Bit, numpy._typing._256Bit]"), "ubyte": f"numpy.unsignedinteger[{dct['_NBitByte']}]", "ushort": f"numpy.unsignedinteger[{dct['_NBitShort']}]", "uintc": f"numpy.unsignedinteger[{dct['_NBitIntC']}]", "uintp": f"numpy.unsignedinteger[{dct['_NBitIntP']}]", "uint": f"numpy.unsignedinteger[{dct['_NBitInt']}]", "ulonglong": f"numpy.unsignedinteger[{dct['_NBitLongLong']}]", "byte": f"numpy.signedinteger[{dct['_NBitByte']}]", "short": f"numpy.signedinteger[{dct['_NBitShort']}]", "intc": f"numpy.signedinteger[{dct['_NBitIntC']}]", "intp": f"numpy.signedinteger[{dct['_NBitIntP']}]", "int_": f"numpy.signedinteger[{dct['_NBitInt']}]", "longlong": f"numpy.signedinteger[{dct['_NBitLongLong']}]", "half": f"numpy.floating[{dct['_NBitHalf']}]", "single": f"numpy.floating[{dct['_NBitSingle']}]", "double": f"numpy.floating[{dct['_NBitDouble']}]", "longdouble": f"numpy.floating[{dct['_NBitLongDouble']}]", "csingle": ("numpy.complexfloating" f"[{dct['_NBitSingle']}, {dct['_NBitSingle']}]"), "cdouble": ("numpy.complexfloating" f"[{dct['_NBitDouble']}, {dct['_NBitDouble']}]"), "clongdouble": ( "numpy.complexfloating" f"[{dct['_NBitLongDouble']}, {dct['_NBitLongDouble']}]" ), # numpy.typing "_NBitInt": dct['_NBitInt'], # numpy.ctypeslib "c_intp": f"ctypes.{_C_INTP}" } #: A dictionary with all supported format keys (as keys) #: and matching values FORMAT_DICT: dict[str, str] = _construct_format_dict() FORMAT_DICT.update(_construct_ctypes_dict()) def _parse_reveals(file: IO[str]) -> tuple[npt.NDArray[np.str_], list[str]]: """Extract and parse all ``" # E: "`` comments from the passed file-like object. All format keys will be substituted for their respective value from `FORMAT_DICT`, *e.g.* ``"{float64}"`` becomes ``"numpy.floating[numpy._typing._64Bit]"``. """ string = file.read().replace("*", "") # Grab all `# E:`-based comments and matching expressions expression_array, _, comments_array = np.char.partition( string.split("\n"), sep=" # E: " ).T comments = "/n".join(comments_array) # Only search for the `{*}` pattern within comments, otherwise # there is the risk of accidentally grabbing dictionaries and sets key_set = set(re.findall(r"\{(.*?)\}", comments)) kwargs = { k: FORMAT_DICT.get(k, f"") for k in key_set } fmt_str = comments.format(**kwargs) return expression_array, fmt_str.split("/n") @pytest.mark.slow @pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed") @pytest.mark.parametrize("path", get_test_cases(REVEAL_DIR)) def test_reveal(path: str) -> None: """Validate that mypy correctly infers the return-types of the expressions in `path`. """ __tracebackhide__ = True with open(path) as fin: expression_array, reveal_list = _parse_reveals(fin) output_mypy = OUTPUT_MYPY assert path in output_mypy for error_line in output_mypy[path]: error_line = _strip_filename(error_line) match = re.match( r"(?P\d+): note: .+$", error_line, ) if match is None: raise ValueError(f"Unexpected reveal line format: {error_line}") lineno = int(match.group('lineno')) - 1 assert "Revealed type is" in error_line marker = reveal_list[lineno] expression = expression_array[lineno] _test_reveal(path, expression, marker, error_line, 1 + lineno) _REVEAL_MSG = """Reveal mismatch at line {} Expression: {} Expected reveal: {!r} Observed reveal: {!r} """ _STRIP_PATTERN = re.compile(r"(\w+\.)+(\w+)") def _test_reveal( path: str, expression: str, reveal: str, expected_reveal: str, lineno: int, ) -> None: """Error-reporting helper function for `test_reveal`.""" stripped_reveal = _STRIP_PATTERN.sub(strip_func, reveal) stripped_expected_reveal = _STRIP_PATTERN.sub(strip_func, expected_reveal) if stripped_reveal not in stripped_expected_reveal: raise AssertionError( _REVEAL_MSG.format(lineno, expression, stripped_expected_reveal, stripped_reveal) ) @pytest.mark.slow @pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed") @pytest.mark.parametrize("path", get_test_cases(PASS_DIR)) def test_code_runs(path: str) -> None: """Validate that the code in `path` properly during runtime.""" path_without_extension, _ = os.path.splitext(path) dirname, filename = path.split(os.sep)[-2:] spec = importlib.util.spec_from_file_location( f"{dirname}.{filename}", path ) assert spec is not None assert spec.loader is not None test_module = importlib.util.module_from_spec(spec) spec.loader.exec_module(test_module) LINENO_MAPPING = { 3: "uint128", 4: "uint256", 6: "int128", 7: "int256", 9: "float80", 10: "float96", 11: "float128", 12: "float256", 14: "complex160", 15: "complex192", 16: "complex256", 17: "complex512", } @pytest.mark.slow @pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed") def test_extended_precision() -> None: path = os.path.join(MISC_DIR, "extended_precision.pyi") output_mypy = OUTPUT_MYPY assert path in output_mypy with open(path) as f: expression_list = f.readlines() for _msg in output_mypy[path]: *_, _lineno, msg_typ, msg = _msg.split(":") msg = _strip_filename(msg) lineno = int(_lineno) expression = expression_list[lineno - 1].rstrip("\n") msg_typ = msg_typ.strip() assert msg_typ in {"error", "note"} if LINENO_MAPPING[lineno] in _EXTENDED_PRECISION_LIST: if msg_typ == "error": raise ValueError(f"Unexpected reveal line format: {lineno}") else: marker = FORMAT_DICT[LINENO_MAPPING[lineno]] _test_reveal(path, expression, marker, msg, lineno) else: if msg_typ == "error": marker = "Module has no attribute" _test_fail(path, expression, marker, msg, lineno) PKgZ001-getopt.phptnu[--TEST-- Console_Getopt --FILE-- $d) { if ($i++ > 0) { print ", "; } print $d[0] . '=' . $d[1]; } print "\n"; print "params: " . implode(", ", $non_opts) . "\n"; print "\n"; } test("-abc", "abc"); test("-abc foo", "abc"); test("-abc foo", "abc:"); test("-abc foo bar gazonk", "abc"); test("-abc foo bar gazonk", "abc:"); test("-a -b -c", "abc"); test("-a -b -c", "abc:"); test("-abc", "ab:c"); test("-abc foo -bar gazonk", "abc"); ?> --EXPECT-- options: a=, b=, c= params: options: a=, b=, c= params: foo options: a=, b=, c=foo params: options: a=, b=, c= params: foo, bar, gazonk options: a=, b=, c=foo params: bar, gazonk options: a=, b=, c= params: Console_Getopt: option requires an argument --c options: a=, b=c params: options: a=, b=, c= params: foo, -bar, gazonk PKgZ bug10557.phptnu[--TEST-- Console_Getopt [bug 10557] --SKIPIF-- --FILE-- getMessage()."\n"; echo 'FATAL'; exit; } print_r($ret); ?> --EXPECT-- Console_Getopt: option requires an argument --to FATALPKgZ bug11068.phptnu[--TEST-- Console_Getopt [bug 11068] --SKIPIF-- --FILE-- getMessage()."\n"; echo 'FATAL'; exit; } print_r($ret); ?> --EXPECT-- Array ( [0] => Array ( [0] => Array ( [0] => f [1] => jjohnston@mail.com ) [1] => Array ( [0] => --to [1] => hi ) ) [1] => Array ( [0] => - ) )PKgZ|EE bug13140.phptnu[--TEST-- Console_Getopt [bug 13140] --SKIPIF-- --FILE-- getopt2($cg->readPHPArgv(), 't', array('test'), true)); print_r($cg->getopt2($cg->readPHPArgv(), 'bar', array('foo'), true)); ?> --EXPECT-- Array ( [0] => Array ( [0] => Array ( [0] => --test [1] => ) ) [1] => Array ( [0] => thisshouldbehere ) ) Array ( [0] => Array ( [0] => Array ( [0] => --foo [1] => ) [1] => Array ( [0] => b [1] => ) [2] => Array ( [0] => a [1] => ) [3] => Array ( [0] => r [1] => ) [4] => Array ( [0] => r [1] => ) ) [1] => Array ( [0] => thisshouldbehere ) ) PKWZAcyclicTestTest.phpnu[addNode($node1); $node2 = new Structures_Graph_Node(); $graph->addNode($node2); $node1->connectTo($node2); $node3 = new Structures_Graph_Node(); $graph->addNode($node3); $node2->connectTo($node3); $node3->connectTo($node1); $this->assertFalse( Structures_Graph_Manipulator_AcyclicTest::isAcyclic($graph), 'Graph is cyclic' ); } public function testIsAcyclicTrue() { $graph = new Structures_Graph(); $node1 = new Structures_Graph_Node(); $graph->addNode($node1); $node2 = new Structures_Graph_Node(); $graph->addNode($node2); $node1->connectTo($node2); $node3 = new Structures_Graph_Node(); $graph->addNode($node3); $node2->connectTo($node3); $this->assertTrue( Structures_Graph_Manipulator_AcyclicTest::isAcyclic($graph), 'Graph is acyclic' ); } } ?> PKWZV AllTests.phpnu[addTestFiles($dir); return $suite; } } PKWZW8j#j#BasicGraphTest.phpnu[ | // +-----------------------------------------------------------------------------+ // require_once dirname(__FILE__) . '/helper.inc'; /** * @access private */ class BasicGraph extends PHPUnit_Framework_TestCase { var $_graph = null; function test_create_graph() { $this->_graph = new Structures_Graph(); $this->assertTrue(is_a($this->_graph, 'Structures_Graph')); } function test_add_node() { $this->_graph = new Structures_Graph(); $data = 1; $node = new Structures_Graph_Node($data); $this->_graph->addNode($node); $node = new Structures_Graph_Node($data); $this->_graph->addNode($node); $node = new Structures_Graph_Node($data); $this->_graph->addNode($node); } function test_connect_node() { $this->_graph = new Structures_Graph(); $data = 1; $node1 = new Structures_Graph_Node($data); $node2 = new Structures_Graph_Node($data); $this->_graph->addNode($node1); $this->_graph->addNode($node2); $node1->connectTo($node2); $node =& $this->_graph->getNodes(); $node =& $node[0]; $node = $node->getNeighbours(); $node =& $node[0]; /* ZE1 == and === operators fail on $node,$node2 because of the recursion introduced by the _graph field in the Node object. So, we'll use the stupid method for reference testing */ $node = true; $this->assertTrue($node2); $node = false; $this->assertFalse($node2); } function test_data_references() { $this->_graph = new Structures_Graph(); $data = 1; $node = new Structures_Graph_Node(); $node->setData($data); $this->_graph->addNode($node); $data = 2; $dataInNode =& $this->_graph->getNodes(); $dataInNode =& $dataInNode[0]; $dataInNode =& $dataInNode->getData(); $this->assertEquals($data, $dataInNode); } function test_metadata_references() { $this->_graph = new Structures_Graph(); $data = 1; $node = new Structures_Graph_Node(); $node->setMetadata('5', $data); $data = 2; $dataInNode =& $node->getMetadata('5'); $this->assertEquals($data, $dataInNode); } function test_metadata_key_exists() { $this->_graph = new Structures_Graph(); $data = 1; $node = new Structures_Graph_Node(); $node->setMetadata('5', $data); $this->assertTrue($node->metadataKeyExists('5')); $this->assertFalse($node->metadataKeyExists('1')); } function test_directed_degree() { $this->_graph = new Structures_Graph(true); $node = array(); $node[] = new Structures_Graph_Node(); $node[] = new Structures_Graph_Node(); $node[] = new Structures_Graph_Node(); $this->_graph->addNode($node[0]); $this->_graph->addNode($node[1]); $this->_graph->addNode($node[2]); $this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 0 arcs'); $this->assertEquals(0, $node[1]->inDegree(), 'inDegree test failed for node 1 with 0 arcs'); $this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 0 arcs'); $this->assertEquals(0, $node[0]->outDegree(), 'outDegree test failed for node 0 with 0 arcs'); $this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 0 arcs'); $this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 0 arcs'); $node[0]->connectTo($node[1]); $this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 1 arc'); $this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 1 arc'); $this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 1 arc'); $this->assertEquals(1, $node[0]->outDegree(), 'outDegree test failed for node 0 with 1 arc'); $this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 1 arc'); $this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 1 arc'); $node[0]->connectTo($node[2]); $this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 2 arcs'); $this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 2 arcs'); $this->assertEquals(1, $node[2]->inDegree(), 'inDegree test failed for node 2 with 2 arcs'); $this->assertEquals(2, $node[0]->outDegree(), 'outDegree test failed for node 0 with 2 arcs'); $this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 2 arcs'); $this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 2 arcs'); } function test_undirected_degree() { $this->_graph = new Structures_Graph(false); $node = array(); $node[] = new Structures_Graph_Node(); $node[] = new Structures_Graph_Node(); $node[] = new Structures_Graph_Node(); $this->_graph->addNode($node[0]); $this->_graph->addNode($node[1]); $this->_graph->addNode($node[2]); $this->assertEquals(0, $node[0]->inDegree(), 'inDegree test failed for node 0 with 0 arcs'); $this->assertEquals(0, $node[1]->inDegree(), 'inDegree test failed for node 1 with 0 arcs'); $this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 0 arcs'); $this->assertEquals(0, $node[0]->outDegree(), 'outDegree test failed for node 0 with 0 arcs'); $this->assertEquals(0, $node[1]->outDegree(), 'outDegree test failed for node 1 with 0 arcs'); $this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 0 arcs'); $node[0]->connectTo($node[1]); $this->assertEquals(1, $node[0]->inDegree(), 'inDegree test failed for node 0 with 1 arc'); $this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 1 arc'); $this->assertEquals(0, $node[2]->inDegree(), 'inDegree test failed for node 2 with 1 arc'); $this->assertEquals(1, $node[0]->outDegree(), 'outDegree test failed for node 0 with 1 arc'); $this->assertEquals(1, $node[1]->outDegree(), 'outDegree test failed for node 1 with 1 arc'); $this->assertEquals(0, $node[2]->outDegree(), 'outDegree test failed for node 2 with 1 arc'); $node[0]->connectTo($node[2]); $this->assertEquals(2, $node[0]->inDegree(), 'inDegree test failed for node 0 with 2 arcs'); $this->assertEquals(1, $node[1]->inDegree(), 'inDegree test failed for node 1 with 2 arcs'); $this->assertEquals(1, $node[2]->inDegree(), 'inDegree test failed for node 2 with 2 arcs'); $this->assertEquals(2, $node[0]->outDegree(), 'outDegree test failed for node 0 with 2 arcs'); $this->assertEquals(1, $node[1]->outDegree(), 'outDegree test failed for node 1 with 2 arcs'); $this->assertEquals(1, $node[2]->outDegree(), 'outDegree test failed for node 2 with 2 arcs'); } } ?> PKWZ6:UUTopologicalSorterTest.phpnu[setData($name1); $graph->addNode($node1); $name11 = 'node11'; $node11 = new Structures_Graph_Node(); $node11->setData($name11); $graph->addNode($node11); $node1->connectTo($node11); $name12 = 'node12'; $node12 = new Structures_Graph_Node(); $node12->setData($name12); $graph->addNode($node12); $node1->connectTo($node12); $name121 = 'node121'; $node121 = new Structures_Graph_Node(); $node121->setData($name121); $graph->addNode($node121); $node12->connectTo($node121); $name2 = 'node2'; $node2 = new Structures_Graph_Node(); $node2->setData($name2); $graph->addNode($node2); $name21 = 'node21'; $node21 = new Structures_Graph_Node(); $node21->setData($name21); $graph->addNode($node21); $node2->connectTo($node21); $nodes = Structures_Graph_Manipulator_TopologicalSorter::sort($graph); $this->assertCount(2, $nodes[0]); $this->assertEquals('node1', $nodes[0][0]->getData()); $this->assertEquals('node2', $nodes[0][1]->getData()); $this->assertCount(3, $nodes[1]); $this->assertEquals('node11', $nodes[1][0]->getData()); $this->assertEquals('node12', $nodes[1][1]->getData()); $this->assertEquals('node21', $nodes[1][2]->getData()); $this->assertCount(1, $nodes[2]); $this->assertEquals('node121', $nodes[2][0]->getData()); } } ?> PKWZ|㲌ii helper.incnu[assertEquals('1.4', XML_Util::apiVersion()); } }PKZZtAttributesToStringTests.phpnu[ 'bar','boo' => 'baz',); $expected = " boo=\"baz\" foo=\"bar\""; $this->assertEquals($expected, XML_Util::attributesToString($original)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithExplicitSortTrue() { $original = array('foo' => 'bar','boo' => 'baz',); $expected = " boo=\"baz\" foo=\"bar\""; $sort = true; $this->assertEquals($expected, XML_Util::attributesToString($original, $sort)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithExplicitSortFalse() { $original = array('foo' => 'bar','boo' => 'baz',); $expected = " foo=\"bar\" boo=\"baz\""; $sort = false; $this->assertEquals($expected, XML_Util::attributesToString($original, $sort)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithMultilineFalse() { $original = array('foo' => 'bar','boo' => 'baz',); $expected = " boo=\"baz\" foo=\"bar\""; $sort = true; $multiline = false; $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithMultilineTrue() { $original = array('foo' => 'bar','boo' => 'baz',); $expected = <<< EOF boo="baz" foo="bar" EOF; $sort = true; $multiline = true; $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithExplicitIndent() { $original = array('foo' => 'bar','boo' => 'baz',); $expected = " boo=\"baz\"\n foo=\"bar\""; $sort = true; $multiline = true; $indent = ' '; // 8 spaces $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $indent)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithExplicitLinebreak() { $original = array('foo' => 'bar','boo' => 'baz',); $expected = " boo=\"baz\"\n^foo=\"bar\""; $sort = true; $multiline = true; $linebreak = '^'; // some dummy character $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithOptionsThatIncludesSort() { $original = array('foo' => 'bar','boo' => 'baz',); $options = array( 'multiline' => true, 'indent' => '----', 'linebreak' => "^", 'entities' => XML_UTIL_ENTITIES_XML, 'sort' => true, ); $expected = " boo=\"baz\"\n----foo=\"bar\""; $this->assertEquals($expected, XML_Util::attributesToString($original, $options)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithOptionsThatExcludesSort() { $original = array('foo' => 'bar','boo' => 'baz',); $options = array( 'multiline' => true, 'indent' => '----', 'linebreak' => "^", 'entities' => XML_UTIL_ENTITIES_XML, ); $expected = " boo=\"baz\"\n----foo=\"bar\""; $this->assertEquals($expected, XML_Util::attributesToString($original, $options)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithEntitiesNone() { $original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_NONE)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithEntitiesXml() { $original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithEntitiesXmlRequired() { $original = array("foo" => "b@&r", "boo" => "b><z\" foo=\"b@&r\""; $sort = true; $multiline = false; $linebreak = ' '; $this->assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_XML_REQUIRED)); } /** * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithEntitiesHtml() { $original = array("foo" => "b@&r", "boo" => "b>assertEquals($expected, XML_Util::attributesToString($original, $sort, $multiline, $linebreak, PHP_EOL, XML_UTIL_ENTITIES_HTML)); } /** * Tag attributes should not be treated as CDATA, * so the operation will instead quietly use XML_UTIL_ENTITIES_XML. * * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithCDataSectionForSingleAttribute() { $original = array('foo' => 'bar'); // need exactly one attribute here $options = array( 'sort' => true, // doesn't matter for this testcase 'multiline' => false, // doesn't matter for this testcase 'indent' => null, // doesn't matter for this testcase 'linebreak' => null, // doesn't matter for this testcase 'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase ); $expected = " foo=\"bar\""; $this->assertEquals($expected, XML_Util::attributesToString($original, $options)); } /** * Tag attributes should not be treated as CDATA, * so the operation will instead quietly use XML_UTIL_ENTITIES_XML. * * @covers XML_Util::attributesToString() */ public function testAttributesToStringWithCDataSectionForMultipleAttributesAndMultilineFalse() { $original = array('foo' => 'bar', 'boo' => 'baz'); // need more than one attribute here $options = array( 'sort' => true, // doesn't matter for this testcase 'multiline' => false, // DOES matter for this testcase, must be false 'indent' => null, // doesn't matter for this testcase 'linebreak' => null, // doesn't matter for this testcase 'entities' => XML_UTIL_CDATA_SECTION, // DOES matter for this testcase ); $expected = " boo=\"baz\" foo=\"bar\""; $this->assertEquals($expected, XML_Util::attributesToString($original, $options)); } } PKZ۩Bug18343Tests.phpnu[ "install", "attributes" => array( "as" => "Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek", "name" => "test/Horde/Feed/fixtures/lexicon/http-p.moreover.com-cgi-local-page%2Fo=rss&s=Newsweek", ) ); public function getFlagsToTest() { new XML_Util(); // for constants to be declared return array( array('no flag', null), array('false', false), array('ENTITIES_NONE', XML_UTIL_ENTITIES_NONE), array('ENTITIES_XML', XML_UTIL_ENTITIES_XML), array('ENTITIES_XML_REQUIRED', XML_UTIL_ENTITIES_XML_REQUIRED), array('ENTITIES_HTML', XML_UTIL_ENTITIES_HTML), array('REPLACE_ENTITIES', XML_UTIL_REPLACE_ENTITIES), ); } /** * @dataProvider getFlagsToTest() */ public function testCreateTagFromArrayForBug18343($key, $flag) { // all flags for the candidate input should return the same result $expected = <<< EOF EOF; $this->assertEquals($expected, XML_Util::createTagFromArray($this->tagArray, $flag), "Failed bugcheck for $key."); } } PKZGBug21177Tests.phpnu['; return array( array('', ''), array('', ''), array('', ''), array('', ''), ); } /** * @dataProvider getTestCandidate() */ public function testCollapseEmptyTagsForBug21177($original, $expected) { $this->assertEquals($expected, XML_Util::collapseEmptyTags($original, XML_UTIL_COLLAPSE_ALL), "Failed bugcheck."); } } PKZYqBug21184Tests.phpnu[one'; $this->assertEquals($xml, XML_Util::collapseEmptyTags($xml, XML_UTIL_COLLAPSE_ALL)); } } PKZ>MBug4950Tests.phpnu[ here!"; $namespaceUrl = null; $expected = " here!]]>"; $result = XML_Util::createTag($qname, $attributes, $content, $namespaceUrl, XML_UTIL_CDATA_SECTION); $this->assertEquals($expected, $result, "Failed bugcheck."); } } PKZGsBug5392Tests.phpnu[, & and " as well as ä, ö, ß, à and ê'; $replacedResult = XML_Util::replaceEntities($original, XML_UTIL_ENTITIES_HTML, "UTF-8"); $reversedResult = XML_Util::reverseEntities($replacedResult, XML_UTIL_ENTITIES_HTML, "UTF-8"); $this->assertEquals($original, $reversedResult, "Failed bugcheck."); } } PKZ|\5CollapseEmptyTagsTests.phpnu["; $expected = ""; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsBasicUsageAlongsideNonemptyTag() { $emptyTag = ""; $otherTag = "baz"; $expected = "baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseAll() { $emptyTag = ""; $expected = ""; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_ALL)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseAll() { $emptyTag = ""; $otherTag = "baz"; $expected = "baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_ALL)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagAlongsideEmptyTagWithCollapseAll() { $emptyTag = ""; $otherTag = "baz"; $expected = "baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyPrefixedTagAlongsideNonemptyTagAlongsideEmptyPrefixedTagWithCollapseAll() { $emptyTag = ""; $otherTag = "baz"; $expected = "baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyNsPrefixedTagAlongsideNonemptyTagAlongsideEmptyNsPrefixedTagWithCollapseAll() { $emptyTag = ""; $otherTag = "baz"; $expected = "baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag . $emptyTag, XML_UTIL_COLLAPSE_ALL)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseXhtml() { $emptyTag = ""; $expected = ""; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_XHTML_ONLY)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseXhtml() { $emptyTag = ""; $otherTag = "baz"; $xhtmlTag = "

"; $expected = "
baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $xhtmlTag . $otherTag, XML_UTIL_COLLAPSE_XHTML_ONLY)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagWithCollapseNone() { $emptyTag = ""; $expected = ""; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag, XML_UTIL_COLLAPSE_NONE)); } /** * @covers XML_Util::collapseEmptyTags() */ public function testCollapseEmptyTagsOnOneEmptyTagAlongsideNonemptyTagWithCollapseNone() { $emptyTag = ""; $otherTag = "baz"; $expected = "baz"; $this->assertEquals($expected, XML_Util::collapseEmptyTags($emptyTag . $otherTag, XML_UTIL_COLLAPSE_NONE)); } } PKZ4ejjCreateCDataSectionTests.phpnu["; $this->assertEquals($expected, XML_Util::createCDataSection($original)); } } PKZTTCreateCommentTests.phpnu["; $this->assertEquals($expected, XML_Util::createComment($original)); } } PKZ~$[eeCreateEndElementTests.phpnu["; $this->assertEquals($expected, XML_Util::createEndElement($original)); } /** * @covers XML_Util::createEndElement() */ public function testCreateEndElementWithNamespacedTag() { $original = "myNs:myTag"; $expected = ""; $this->assertEquals($expected, XML_Util::createEndElement($original)); } } PKZYR""CreateStartElementTests.phpnu["; $this->assertEquals($expected, XML_Util::createStartElement($original)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributes() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $expected = ""; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithEmptyAttributes() { $originalTag = "myNs:myTag"; $originalAttributes = ""; $expected = ""; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributesAndNamespace() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalNamespace = "http://www.w3c.org/myNs#"; $expected = ""; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithEmptyAttributesAndNonUriNamespace() { $originalTag = "myTag"; $originalAttributes = ""; $originalNamespace = "foo"; $expected = ""; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultiline() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalNamespace = "http://www.w3c.org/myNs#"; $expected = <<< EOF EOF; $multiline = true; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndent() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalNamespace = "http://www.w3c.org/myNs#"; $expected = <<< EOF EOF; $multiline = true; $indent = " "; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreak() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalNamespace = "http://www.w3c.org/myNs#"; $expected = ""; $multiline = true; $indent = " "; $linebreak = "^"; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsTrue() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar", "boo" => "baz"); $originalNamespace = "http://www.w3c.org/myNs#"; $expected = ""; $multiline = true; $indent = " "; $linebreak = "^"; $sortAttributes = true; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes)); } /** * @covers XML_Util::createStartElement() */ public function testCreateStartElementForTagWithAttributesAndNamespaceWithMultilineAndIndentAndLinebreakAndSortAttributesIsFalse() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar", "boo" => "baz"); $originalNamespace = "http://www.w3c.org/myNs#"; $expected = ""; $multiline = true; $indent = " "; $linebreak = "^"; $sortAttributes = false; $this->assertEquals($expected, XML_Util::createStartElement($originalTag, $originalAttributes, $originalNamespace, $multiline, $indent, $linebreak, $sortAttributes)); } } PKZe>44CreateTagFromArrayTests.phpnu[ "foo:bar", ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespace() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributes() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContent() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndAttributesAndContent() { $original = array( "qname" => "foo:bar", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndContent() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "content" => "I'm inside the tag", ); $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithEntitiesNone() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_ENTITIES_NONE)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntities() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineFalse() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $multiline = false; $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrue() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $multiline = true; $expected = <<< EOF I'm inside the tag EOF; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndent() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $multiline = true; $indent = " "; $expected = <<< EOF I'm inside the tag EOF; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $multiline = true; $indent = " "; $linebreak = "^"; $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $multiline = true; $indent = " "; $linebreak = "^"; $sortAttributes = true; $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameAndNamespaceAndAttributesAndContentWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse() { $original = array( "qname" => "foo:bar", "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $multiline = true; $indent = " "; $linebreak = "^"; $sortAttributes = false; $expected = "I'm inside the tag"; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithInvalidArray() { $badArray = array( "foo" => "bar", ); $expectedError = "You must either supply a qualified name (qname) or local tag name (localPart)."; $this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithNamespaceAndAttributesAndContentButWithoutQname() { $original = array( "namespaceUri" => "http://foo.com", "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), "content" => "I'm inside the tag", ); $expectedError = "You must either supply a qualified name (qname) or local tag name (localPart)."; $this->assertEquals($expectedError, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithNonScalarContent() { $badArray = array( 'content' => array('foo', 'bar'), ); $expectedError = "Supplied non-scalar value as tag content"; $this->assertEquals($expectedError, XML_Util::createTagFromArray($badArray)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithArrayOfNamespaces() { $original = array( 'qname' => 'foo:bar', 'namespaces' => array('ns1' => 'uri1', 'ns2' => 'uri2'), ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameDerivedFromNamespaceUriAndLocalPart() { $original = array( 'namespaceUri' => 'http://bar.org', 'localPart' => 'foo' ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameDerivedFromNamespaceAndLocalPart() { $original = array( 'namespace' => 'http://foo.org', 'localPart' => 'bar' ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithQnameDerivedFromLocalPart() { $original = array( 'namespace' => '', 'localPart' => 'bar' ); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original)); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayWithImplicitlyEmptyContentAndCollapseNoneDoesNotCollapseTag() { $original = array('qname' => 'tag1'); $expected = ""; $actual = XML_Util::createTagFromArray( $original, XML_UTIL_REPLACE_ENTITIES, // default $replaceEntities false, // default $multiline '_auto', // default $indent "\n", // default $linebreak true, // default $sortAttributes XML_UTIL_COLLAPSE_NONE ); $this->assertEquals($expected, $actual); } /** * @covers XML_Util::createTagFromArray() */ public function testCreateTagFromArrayForCdataWithExplicitlyEmptyContentDoesNotCollapseTag() { $original = array('qname' => 'tag1', 'content' => ''); $expected = ""; $this->assertEquals($expected, XML_Util::createTagFromArray($original, XML_UTIL_CDATA_SECTION)); } } PKZm4**CreateTagTests.phpnu[ "bar"); $expected = ""; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContent() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag"; $expected = "This is inside the tag"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespace() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag"; $originalNamespace = "http://www.w3c.org/myNs#"; $expected = "This is inside the tag"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithCDataSection() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $expected = " in it]]>"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_CDATA_SECTION)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntities() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $expected = "This is inside the tag and has < & @ > in it"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineFalse() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $multiline = false; $expected = "This is inside the tag and has < & @ > in it"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrue() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $multiline = true; $expected = <<< EOF This is inside the tag and has < & @ > in it EOF; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndent() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $multiline = true; $indent = " "; $expected = <<< EOF This is inside the tag and has < & @ > in it EOF; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreak() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $multiline = true; $indent = " "; $linebreak = "^"; $expected = "This is inside the tag and has < & @ > in it"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesTrue() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar", "boo" => "baz"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $multiline = true; $indent = " "; $linebreak = "^"; $sortAttributes = true; $expected = "This is inside the tag and has < & @ > in it"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes)); } /** * @covers XML_Util::createTag() */ public function testCreateTagForTagWithAttributesAndContentAndNamespaceWithReplaceEntitiesAndMultilineTrueAndIndentAndLinebreakAndSortAttributesFalse() { $originalTag = "myNs:myTag"; $originalAttributes = array("foo" => "bar", "boo" => "baz"); $originalContent = "This is inside the tag and has < & @ > in it"; $originalNamespace = "http://www.w3c.org/myNs#"; $multiline = true; $indent = " "; $linebreak = "^"; $sortAttributes = false; $expected = "This is inside the tag and has < & @ > in it"; $this->assertEquals($expected, XML_Util::createTag($originalTag, $originalAttributes, $originalContent, $originalNamespace, XML_UTIL_REPLACE_ENTITIES, $multiline, $indent, $linebreak, $sortAttributes)); } } PKZܬ$GetDocTypeDeclarationTests.phpnu["; $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag")); } /** * @covers XML_Util::getDocTypeDeclaration() */ public function testGetDocTypeDeclarationUsingRootAndStringUri() { $expected = ""; $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", "myDocType.dtd")); } /** * @covers XML_Util::getDocTypeDeclaration() */ public function testGetDocTypeDeclarationUsingRootAndArrayUri() { $uri = array( 'uri' => 'http://pear.php.net/dtd/package-1.0', 'id' => '-//PHP//PEAR/DTD PACKAGE 0.1' ); $expected = ""; $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri)); } /** * @covers XML_Util::getDocTypeDeclaration() */ public function testGetDocTypeDeclarationUsingRootAndArrayUriAndInternalDtd() { $uri = array( 'uri' => 'http://pear.php.net/dtd/package-1.0', 'id' => '-//PHP//PEAR/DTD PACKAGE 0.1' ); $dtdEntry = ''; $expected = <<< EOF ]> EOF; $this->assertEquals($expected, XML_Util::getDocTypeDeclaration("rootTag", $uri, $dtdEntry)); } } PKZDf:GetXmlDeclarationTests.phpnu["; $this->assertEquals($expected, XML_Util::getXMLDeclaration($version)); } /** * @covers XML_Util::getXMLDeclaration() */ public function testGetXMLDeclarationUsingVersionAndEncodingAndStandalone() { $version = "1.0"; $encoding = "UTF-8"; $standalone = true; $expected = ""; $this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone)); } /** * @covers XML_Util::getXMLDeclaration() */ public function testGetXMLDeclarationUsingVersionAndStandalone() { $version = "1.0"; $encoding = null; $standalone = true; $expected = ""; $this->assertEquals($expected, XML_Util::getXMLDeclaration($version, $encoding, $standalone)); } } PKZݑhIsValidNameTests.phpnu[assertTrue($result); } /** * @covers XML_Util::isValidName() */ public function testIsValidNameForTagNameWithInvalidCharacter() { $tagName = "invalidTag?"; $result = XML_Util::isValidName($tagName); $this->assertInstanceOf('PEAR_Error', $result); $expectedError = "XML names may only contain alphanumeric chars, period, hyphen, colon and underscores"; $this->assertEquals($expectedError, $result->getMessage()); } /** * @covers XML_Util::isValidName() */ public function testIsValidNameForTagNameWithInvalidStartingCharacter() { $tagName = "1234five"; $result = XML_Util::isValidName($tagName); $this->assertInstanceOf('PEAR_Error', $result); $expectedError = "XML names may only start with letter or underscore"; $this->assertEquals($expectedError, $result->getMessage()); } /** * @covers XML_Util::isValidName() */ public function testIsValidNameForInt() { $tagName = 1; $result = XML_Util::isValidName($tagName); $this->assertInstanceOf('PEAR_Error', $result); $expectedError = "XML names may only start with letter or underscore"; $this->assertEquals($expectedError, $result->getMessage()); } /** * @covers XML_Util::isValidName() */ public function testIsValidNameForEmptyString() { $tagName = ''; $result = XML_Util::isValidName($tagName); $this->assertInstanceOf('PEAR_Error', $result); $expectedError = "XML names may only start with letter or underscore"; $this->assertEquals($expectedError, $result->getMessage()); } } PKZrvRaiseErrorTests.phpnu[assertInstanceOf('PEAR_Error', $error); $this->assertEquals($message, $error->getMessage()); $this->assertEquals($code, $error->getCode()); } } PKZCReplaceEntitiesTests.phpnu[.'; } protected function getUtf8Data() { return 'This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê'; } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleData() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData())); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), 'INVALID_OPTION')); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithEntitiesXml() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithEntitiesXmlAndEncoding() { $encoding = "UTF-8"; $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML, $encoding)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForUtf8DataWithEntitiesXmlAndEncoding() { $encoding = "UTF-8"; $expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê"; $this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML, $encoding)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequired() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding() { $encoding = "UTF-8"; $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding() { $encoding = "UTF-8"; $expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê"; $this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithEntitiesHtml() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForSimpleDataWithEntitiesHtmlAndEncoding() { $encoding = "UTF-8"; $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::replaceEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding)); } /** * @covers XML_Util::replaceEntities() */ public function testReplaceEntitiesForUtf8DataWithEntitiesHtmlAndEncoding() { $encoding = "UTF-8"; $expected = "This data contains special chars like <, >, & and " as well as ä, ö, ß, à and ê"; $this->assertEquals($expected, XML_Util::replaceEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding)); } } PKZztReverseEntitiesTests.phpnu[."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData())); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithInvalidOptionReturnsOriginalData() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), 'INVALID_OPTION')); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithEntitiesXml() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML)); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithEntitiesXmlAndEncoding() { $encoding = "UTF-8"; $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML), $encoding); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForUtf8DataWithEntitiesXmlAndEncoding() { $encoding = "UTF-8"; $expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê"; $this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML), $encoding); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequired() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED)); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithEntitiesXmlRequiredAndEncoding() { $encoding = "UTF-8"; $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding)); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForUtf8DataWithEntitiesXmlRequiredAndEncoding() { $encoding = "UTF-8"; $expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê"; $this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_XML_REQUIRED, $encoding)); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithEntitiesHtml() { $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML)); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForSimpleDataWithEntitiesHtmlAndEncoding() { $encoding = "UTF-8"; $expected = "This string contains < & >."; $this->assertEquals($expected, XML_Util::reverseEntities($this->getSimpleData(), XML_UTIL_ENTITIES_HTML, $encoding)); } /** * @covers XML_Util::reverseEntities() */ public function testReverseEntitiesForUtf8DataWithEntitiesHtmlAndEncoding() { $encoding = "UTF-8"; $expected = "This data contains special chars like <, >, & and \" as well as ä, ö, ß, à and ê"; $this->assertEquals($expected, XML_Util::reverseEntities($this->getUtf8Data(), XML_UTIL_ENTITIES_HTML, $encoding)); } } PKZGGSplitQualifiedNameTests.phpnu[ 'xslt', 'localPart' => 'stylesheet', ); $this->assertEquals($expected, XML_Util::splitQualifiedName($original)); } /** * @covers XML_Util::splitQualifiedName() */ public function testSplitQualifiedNameWithNamespace() { $original = "stylesheet"; $namespace = "myNs"; $expected = array( 'namespace' => 'myNs', 'localPart' => 'stylesheet', ); $this->assertEquals($expected, XML_Util::splitQualifiedName($original, $namespace)); } } PKIZ __init__.pynu[PKIZydata/pass/__pycache__/ndarray_conversion.cpython-311.pycnu[PKIZu6621data/pass/__pycache__/numerictypes.cpython-311.pycnu[PKIZF8ɯdata/pass/__pycache__/array_constructors.cpython-311.pycnu[PKIZے] ] 0?data/pass/__pycache__/array_like.cpython-311.pycnu[PKIZbb,data/pass/__pycache__/random.cpython-311.pycnu[PKIZq0ddata/pass/__pycache__/arrayprint.cpython-311.pycnu[PKIZZ'3030-0kdata/pass/__pycache__/scalars.cpython-311.pycnu[PKIZU2JJ2data/pass/__pycache__/arrayterator.cpython-311.pycnu[PKIZ H H 1ldata/pass/__pycache__/bitwise_ops.cpython-311.pycnu[PKIZCepp,data/pass/__pycache__/simple.cpython-311.pycnu[PKIZ1data/pass/__pycache__/comparisons.cpython-311.pycnu[PKIZ4- - +Vdata/pass/__pycache__/dtype.cpython-311.pycnu[PKIZ8 8 0data/pass/__pycache__/einsumfunc.cpython-311.pycnu[PKIZp}aa0vdata/pass/__pycache__/simple_py3.cpython-311.pycnu[PKIZX.7data/pass/__pycache__/flatiter.cpython-311.pycnu[PKIZ6//1data/pass/__pycache__/fromnumeric.cpython-311.pycnu[PKIZTgg2:$data/pass/__pycache__/ufunc_config.cpython-311.pycnu[PKIZWf7724data/pass/__pycache__/index_tricks.cpython-311.pycnu[PKIZ-y /Bdata/pass/__pycache__/ufunclike.cpython-311.pycnu[PKIZj/Ndata/pass/__pycache__/lib_utils.cpython-311.pycnu[PKIZ]iµ1Sdata/pass/__pycache__/lib_version.cpython-311.pycnu[PKIZl, ,Vdata/pass/__pycache__/ufuncs.cpython-311.pycnu[PKIZȦ -[data/pass/__pycache__/literal.cpython-311.pycnu[PKIZ$)fdata/pass/__pycache__/mod.cpython-311.pycnu[PKIZS ''-wdata/pass/__pycache__/modules.cpython-311.pycnu[PKIZcAĿ559 ~data/pass/__pycache__/warnings_and_errors.cpython-311.pycnu[PKIZn}< < 0data/pass/__pycache__/multiarray.cpython-311.pycnu[PKIZo -Zdata/pass/__pycache__/numeric.cpython-311.pycnu[PKIZdata/pass/random.pynu[PKIZCo G0data/pass/scalars.pynu[PKIZ赫t t ">data/pass/simple.pynu[PKIZzT``Hdata/pass/simple_py3.pynu[PKIZj7``Idata/pass/ufunc_config.pynu[PKIZ3)Ndata/pass/ufunclike.pynu[PKIZ~Rdata/pass/ufuncs.pynu[PKIZ/ Tdata/pass/warnings_and_errors.pynu[PKIZsEQEQuUdata/reveal/arithmetic.pyinu[PKIZƻg g data/reveal/ufuncs.pyinu[PKIZ7.7."data/reveal/array_constructors.pyinu[PKIZGa:data/reveal/arraypad.pyinu[PKIZ62E8data/reveal/arrayprint.pyinu[PKIZJ]??0data/reveal/arraysetops.pyinu[PKIZW"chhdata/reveal/arrayterator.pyinu[PKIZkndata/reveal/bitwise_ops.pyinu[PKIZk=oo data/reveal/char.pyinu[PKIZ/6E,data/reveal/chararray.pyinu[PKIZX6RRtEdata/reveal/comparisons.pyinu[PKIZHX edata/reveal/constants.pyinu[PKIZ]ldata/reveal/ctypeslib.pyinu[PKIZ:--*data/reveal/datasource.pyinu[PKIZR data/reveal/dtype.pyinu[PKIZ*}}Ɏdata/reveal/einsumfunc.pyinu[PKIZi˳ data/reveal/emath.pyinu[PKIZ ײ]]data/reveal/false_positives.pyinu[PKIZz&~<<kdata/reveal/fft.pyinu[PKIZ+u33data/reveal/flatiter.pyinu[PKIZj^?5?5edata/reveal/fromnumeric.pyinu[PKIZSK  data/reveal/getlimits.pyinu[PKIZOooCdata/reveal/histograms.pyinu[PKIZ%h data/reveal/index_tricks.pyinu[PKIZn,e##!data/reveal/lib_function_base.pyinu[PKIZj!data/reveal/lib_polynomial.pyinu[PKIZ;data/reveal/lib_utils.pyinu[PKIZ5]]>data/reveal/lib_version.pyinu[PKIZ˴zaaAdata/reveal/linalg.pyinu[PKIZâ5 2Vdata/reveal/matrix.pyinu[PKIZx/Qbdata/reveal/memmap.pyinu[PKIZo7eeedata/reveal/mod.pyinu[PKIZ=Y2}data/reveal/modules.pyinu[PKIZRB&&Cdata/reveal/multiarray.pyinu[PKIZ}99data/reveal/version.pyinu[PKIZtF!3data/reveal/nbit_base_example.pyinu[PKIZ*N!#xdata/reveal/warnings_and_errors.pyinu[PKIZd4 2yy"odata/reveal/ndarray_conversion.pyinu[PKIZ&uu:data/reveal/ndarray_misc.pyinu[PKIZr~,''data/reveal/ufunclike.pyinu[PKIZLۈ*kdata/reveal/ndarray_shape_manipulation.pyinu[PKIZ=FMdata/reveal/nditer.pyinu[PKIZR;data/reveal/nested_sequence.pyinu[PKIZ;RR}data/reveal/npyio.pyinu[PKIZ[0data/reveal/numeric.pyinu[PKIZD# data/reveal/numerictypes.pyinu[PKIZYO data/reveal/random.pyinu[PKIZZ/4 4  data/reveal/rec.pyinu[PKIZ1 H data/reveal/scalars.pyinu[PKIZjH H , data/reveal/shape_base.pyinu[PKIZwtG7 data/reveal/stride_tricks.pyinu[PKIZ\""= data/reveal/testing.pyinu[PKIZ>| ` data/reveal/twodim_base.pyinu[PKIZQe5: m data/reveal/type_check.pyinu[PKIZ)z data/reveal/ufunc_config.pyinu[PKIZ_,,r test_isfile.pynu[PKIZ|h ܂ test_runtime.pynu[PKIZy;; test_typing.pynu[PKgZ 001-getopt.phptnu[PKgZ  bug10557.phptnu[PKgZ ' bug11068.phptnu[PKgZ|EE } bug13140.phptnu[PKWZ AcyclicTestTest.phpnu[PKWZV ^ AllTests.phpnu[PKWZW8j#j#V BasicGraphTest.phpnu[PKWZ6:UU TopologicalSorterTest.phpnu[PKWZ|㲌ii  helper.incnu[PKZ!C AbstractUnitTests.phpnu[PKZیu0 ApiVersionTests.phpnu[PKZZtP AttributesToStringTests.phpnu[PKZ۩1 Bug18343Tests.phpnu[PKZG8 Bug21177Tests.phpnu[PKZYq= Bug21184Tests.phpnu[PKZ>M"? Bug4950Tests.phpnu[PKZGs;B Bug5392Tests.phpnu[PKZ|\5zE CollapseEmptyTagsTests.phpnu[PKZ4ejjV CreateCDataSectionTests.phpnu[PKZTTzX CreateCommentTests.phpnu[PKZ~$[eeZ CreateEndElementTests.phpnu[PKZYR""\ CreateStartElementTests.phpnu[PKZe>44/r CreateTagFromArrayTests.phpnu[PKZm4**. CreateTagTests.phpnu[PKZܬ$ GetDocTypeDeclarationTests.phpnu[PKZDf: GetXmlDeclarationTests.phpnu[PKZݑh IsValidNameTests.phpnu[PKZrv RaiseErrorTests.phpnu[PKZC ReplaceEntitiesTests.phpnu[PKZzt ReverseEntitiesTests.phpnu[PKZGG SplitQualifiedNameTests.phpnu[PKH