&`i5ddlZddlZddlmZmZmZmZmZmZm Z ddl Z ddl Z ddlZddlmZddlmZddlmZddlmZmZddlmZmZddlmZmZdd lm Z  dd lm!Z!n#e"$r dd lm#Z!YnwxYwd ee$fd Z%d ee$fdZ&dZ'ej(e'ddkree j)edkr ddl*m+Z+e+Z,nddl*m-Z-e-Z,e,j.e,_/edee j)cxkredkr nne%e,_.ne&e,_.de,_0e de j1j2j3Gdde j1j2j4Z5Gdde j1j2j6Z7GddZ8e dGdd e7e8Z9e dGd!d"e j1j2j:e7e8Z;e9<e9=e9>e;<e;=e;>e dd#e j?d e@fd$ZAdS)%N)AnyCallableListOptionalSequenceTupleUnion)Version)Dtype)set_function_name) ABCDataFrame ABCSeries)check_array_indexervalidate_indices)_create_possibly_ragged_ndarray"_is_ndarray_variable_shaped_tensor) PublicAPI)ABCIndex) ABCIndexClassreturnc$ ddlm}ddlm t jt sS|jd}tj |}|j dkrS fd}j }|| d}| d }tj |||}|jjrd nd }||j| } || dS) Nr extract_array format_arrayT extract_numpyc ||jjjjjjjj }|S)N float_formatna_repdigitsspacejustifydecimal leading_spacequotingr array_ formatter_ fmt_valuesrselfs y/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/ray/air/util/tensor_extensions/pandas.pyformat_array_wrapz2_format_strings_patched..format_array_wrapMsQ!\  *;;*LL,L    boxedKFCorder)pandas.core.constructionrpandas.io.formats.formatr isinstancevalues TensorArray_format_strings_orignpasarrayndim formatter _formatterravelflags f_contiguousreshapeshape) r-rr;arrayr/flat_formatter flat_arrayfmt_flat_arrayr7 fmt_arrayrs ` @r._format_strings_patchedrM@sE666666555555 dk; / /+((*** ]4;d ; ; ;F Jv  E zQ((***      ^N***66S!!JZ 1 1*n M MNNN;+ 4CCE&&u{%&@@I  Y - --r0cV ddlm ddlm}ddlm ddlm tj ts S|j d}tj |}|jdkr S fd }j}||d }|d }tj |||}|jjrd nd }||j|} fd} | | jS)Nr)partialrr) pprint_thingTrrc v||jjjjjjj }|S)Nr!r"r#r$r%r&r'rRr)s r.r/z9_format_strings_patched_v1_0_0..format_array_wrapzsL!\  *;;*LL,    r0r1r3r4r5r6cdfd}g}|D]<}|durdnd}||||=|S)N)   ) escape_charsc4t|SNstr)xrAs r._formatzL_format_strings_patched_v1_0_0..format_strings_slim.._formatsyy||$$ $r0Fz{v}z {v})v)appendformat) r*r'r]r,r^tplrArOrPs @r.format_strings_slimz;_format_strings_patched_v1_0_0..format_strings_slimsG +    % % % % %  8 8A(E11%%vC   cjj771::j66 7 7 7 7r0) functoolsrOr8rr9rpandas.io.formats.printingrPr:r;r<r=r>r?r@rArBrCrDrErFrGr')r-rr;rHr/rIrJrKr7rLrbrrOrPs` @@@r._format_strings_patched_v1_0_0rejs!!!!!!666666555555777777 dk; / /+((*** ]4;d ; ; ;F Jv  E zQ((***      ^N***66S!!JZ 1 1*n M MNNN;+ 4CCE&&u{%&@@I        y$*< = ==r0)TENSOR_COLUMN_EXTENSION_FORMATTER_ENABLED1z2.2.0)ExtensionArrayFormatter)_ExtensionArrayFormatterz1.1.0z1.3.0Tbeta) stabilitycPeZdZdZdZdeeedfdej fdZ e dZ e dZ e d Ze d Ze d efd Zed efdZedZdeejejffdZd efdZd efdZe dZdS) TensorDtypea Pandas extension type for a column of homogeneous-typed tensors. This extension supports tensors in which the elements have different shapes. However, each tensor element must be non-ragged, i.e. each tensor element must have a well-defined, non-ragged shape. See: https://github.com/pandas-dev/pandas/blob/master/pandas/core/dtypes/base.py for up-to-date interface documentation and the subclassing contract. The docstrings of the below properties and methods were copied from the base ExtensionDtype. Examples: >>> # Create a DataFrame with a list of ndarrays as a column. >>> import pandas as pd >>> import numpy as np >>> import ray >>> df = pd.DataFrame({ ... "one": [1, 2, 3], ... "two": list(np.arange(24).reshape((3, 2, 2, 2)))}) >>> # Note the opaque np.object dtype for this column. >>> df.dtypes # doctest: +SKIP one int64 two object dtype: object >>> # Cast column to our TensorDtype extension type. >>> from ray.data.extensions import TensorDtype >>> df["two"] = df["two"].astype(TensorDtype(np.int64, (3, 2, 2, 2))) >>> # Note that the column dtype is now TensorDtype instead of >>> # np.object. >>> df.dtypes # doctest: +SKIP one int64 two TensorDtype(shape=(3, 2, 2, 2), dtype=int64) dtype: object >>> # Pandas is now aware of this tensor column, and we can do the >>> # typical DataFrame operations on this column. >>> col = 2 * (df["two"] + 10) >>> # The ndarrays underlying the tensor column will be manipulated, >>> # but the column itself will continue to be a Pandas type. >>> type(col) # doctest: +SKIP pandas.core.series.Series >>> col # doctest: +SKIP 0 [[[ 2 4] [ 6 8]] [[10 12] [14 16]]] 1 [[[18 20] [22 24]] [[26 28] [30 32]]] 2 [[[34 36] [38 40]] [[42 44] [46 48]]] Name: two, dtype: TensorDtype(shape=(3, 2, 2, 2), dtype=int64) >>> # Once you do an aggregation on that column that returns a single >>> # row's value, you get back our TensorArrayElement type. >>> tensor = col.mean() >>> type(tensor) # doctest: +SKIP ray.data.extensions.tensor_extension.TensorArrayElement >>> tensor # doctest: +SKIP array([[[18., 20.], [22., 24.]], [[26., 28.], [30., 32.]]]) >>> # This is a light wrapper around a NumPy ndarray, and can easily >>> # be converted to an ndarray. >>> type(tensor.to_numpy()) # doctest: +SKIP numpy.ndarray >>> # In addition to doing Pandas operations on the tensor column, >>> # you can now put the DataFrame into a Dataset. >>> ds = ray.data.from_pandas(df) # doctest: +SKIP >>> # Internally, this column is represented the corresponding >>> # Arrow tensor extension type. >>> ds.schema() # doctest: +SKIP one: int64 two: extension> >>> # You can write the dataset to Parquet. >>> ds.write_parquet("/some/path") # doctest: +SKIP >>> # And you can read it back. >>> read_ds = ray.data.read_parquet("/some/path") # doctest: +SKIP >>> read_ds.schema() # doctest: +SKIP one: int64 two: extension> >>> read_df = ray.get(read_ds.to_pandas_refs())[0] # doctest: +SKIP >>> read_df.dtypes # doctest: +SKIP one int64 two TensorDtype(shape=(3, 2, 2, 2), dtype=int64) dtype: object >>> # The tensor extension type is preserved along the >>> # Pandas --> Arrow --> Parquet --> Arrow --> Pandas >>> # conversion chain. >>> read_df.equals(df) # doctest: +SKIP True NrG.dtypec"||_||_dSrY_shape_dtype)r-rGrns r.__init__zTensorDtype.__init__&s  r0ctS)a  The scalar type for the array, e.g. ``int`` It's expected ``ExtensionArray[item]`` returns an instance of ``ExtensionDtype.type`` for scalar ``item``, assuming that value is valid (not NA). NA values do not need to be instances of `type`. )TensorArrayElementr-s r.typezTensorDtype.type*s "!r0c|jS)z> The dtype of the underlying tensor elements. )rrrvs r. element_dtypezTensorDtype.element_dtype5s {r0c|jS)z The shape of the underlying tensor elements. This will be a tuple of Nones if the corresponding TensorArray for this TensorDtype holds variable-shaped tensor elements. )rqrvs r. element_shapezTensorDtype.element_shape<s {r0c>td|jDS)z{ Whether the corresponding TensorArray for this TensorDtype holds variable-shaped tensor elements. c3K|]}|duV dSrY).0dim_sizes r. z1TensorDtype.is_variable_shaped..Ks'??8t#??????r0)allrGrvs r.is_variable_shapedzTensorDtype.is_variable_shapedEs# ??DJ??????r0rc(d|jd|jdS)zp A string identifying the data type. Will be used for display in, e.g. ``Series.dtype`` zTensorDtype(shape=z, dtype=)rprvs r.namezTensorDtype.nameMs" HDKGGGGGGr0stringcddl}ddl}t|tst dt |d}|||}d|jd|d}|t ||}t|dkrt ||\}} } | | } tj | } || | S) a= Construct this type from a string. This is useful mainly for data types that accept parameters. For example, a period dtype accepts a frequency parameter that can be set as ``period[H]`` (where H means hourly frequency). By default, in the abstract class, just the name of the type is expected. But subclasses can overwrite this method to accept parameters. Parameters ---------- string : str The name of the type, for example ``category``. Returns ------- ExtensionDtype Instance of the dtype. Raises ------ TypeError If a class cannot be constructed from this 'string'. Examples -------- For extension dtypes with arguments the following may be an adequate implementation. >>> import re >>> @classmethod ... def construct_from_string(cls, string): ... pattern = re.compile(r"^my_type\[(?P.+)\]$") ... match = pattern.match(string) ... if match: ... return cls(**match.groupdict()) ... else: ... raise TypeError( ... f"Cannot construct a '{cls.__name__}' from '{string}'" ... ) rNz.'construct_from_string' expects a string, got zP^(TensorDtype|numpy.ndarray)\(shape=(\((?:(?:\d+|None),?\s?)*\)), dtype=(\w+)\)$zCannot construct a 'z' from 'zF'; expected a string like 'TensorDtype(shape=(1, 2, 3), dtype=int64)'.) astrer:r[ TypeErrorrwsearch__name__groupslen literal_evalr>rn) clsrrrregexmerr_msgr_rGrns r.construct_from_stringz!TensorDtype.construct_from_stringUsZ   &#&& OfOO   D  IIeV $ $ @3< @ @ @ @ @  9G$$ $ v;;!  G$$ $ 5%  ''s5%   r0ctS)zq Return the array type associated with this dtype. Returns ------- type )r<)rs r.construct_array_typez TensorDtype.construct_array_types r0rHcDt|tjrd|jdkr1t jd|D}n<|d}n|}t|S)a| Convert a pyarrow (chunked) array to a TensorArray. This and TensorArray.__arrow_array__ make up the Pandas extension type + array <--> Arrow extension type + array interoperability protocol. See https://pandas.pydata.org/pandas-docs/stable/development/extending.html#compatibility-with-apache-arrow for more information. rc6g|]}|Sr~)to_numpy)rchunks r. z.TensorDtype.__from_arrow__..s"FFF%U^^%%FFFr0r) r:pa ChunkedArray num_chunksr> concatenate iterchunksrrr<)r-rHr;s r.__from_arrow__zTensorDtype.__from_arrow__s eR_ - - &!##FF53C3C3E3EFFFQ0022^^%%F6"""r0c|jSrY)rrvs r.__str__zTensorDtype.__str__s yr0c t|SrYrZrvs r.__repr__zTensorDtype.__repr__s4yyr0c.ddlm}||jS)B Whether this extension array should be considered boolean. By default, ExtensionArrays are assumed to be non-numeric. Setting this to True will affect the behavior of several places, e.g. * is_bool * boolean indexing Returns ------- bool r) is_bool_dtype)pandas.core.dtypes.commonrrr)r-rs r. _is_booleanzTensorDtype._is_booleans(" <;;;;;}T[)))r0)r __module__ __qualname____doc__baserrintr>rnrspropertyrwryr{rr[r classmethodrrr rArrayrrrrrr~r0r.rmrms__H DeHSM3$67""X"X X@@X@HcHHHXHF!3F!F!F![F!P[#E"(BO*C$D####0#**X***r0rmc@eZdZdZeddZedZdS)_TensorOpsMixinze Mixin for TensorArray operator support, applying operations on the underlying ndarrays. TNcNfd}djdt|S)zc Add support for binary operators by unwrapping, applying, and rewrapping. c|j}t|tttfrt Sdvrt t|ttfr|j}n|}||}t|tr9t|trtj |st|}n |}|S)N) __divmod__ __rdivmod__) _tensorr:r rrNotImplementedNotImplementedErrorr<rur>isscalar) r-otherlvaluesrvaluesresultresult_wrappedropop_names r._binopz._TensorOpsMixin._create_method.._binopslG%, 8!DEE &%%777*)%+/A!BCC -R))F$ 233 -u&899 -ACUASAS -"-V!4!4!$V! !r0__)rr )rrcoerce_to_dtype result_dtyperrs`` @r._create_methodz_TensorOpsMixin._create_methodsN " " " " " " "<'r{&&& #666r0c,||SrY)r)rrs r._create_logical_methodz&_TensorOpsMixin._create_logical_methods!!"%%%r0)TN)rrrrrrrr~r0r.rrsZ (7(7(7[(7T&&[&&&r0rcNeZdZdZdeegeffdZdZdZdZ dZ dZ d S) _TensorScalarCastMixinzH Mixin for casting scalar tensors to a particular numeric type. funcc"||jSrYr)r-rs r. _scalarfuncz"_TensorScalarCastMixin._scalarfuncstDL!!!r0c6|tSrY)rcomplexrvs r. __complex__z"_TensorScalarCastMixin.__complex__s(((r0c6|tSrY)rfloatrvs r. __float__z _TensorScalarCastMixin.__float__s&&&r0c6|tSrY)rrrvs r.__int__z_TensorScalarCastMixin.__int__!$$$r0c6|tSrY)rhexrvs r.__hex__z_TensorScalarCastMixin.__hex__$rr0c6|tSrY)roctrvs r.__oct__z_TensorScalarCastMixin.__oct__'rr0N) rrrrrrrrrrrrr~r0r.rrs"# 4"""")))'''%%%%%%%%%%%r0rceZdZdZdejfdZdZdZe dZ e dZ e dZ e d Z d Zdd ejd ejfdZd S)ruzJ Single element of a TensorArray, wrapping an underlying ndarray. r;c||_dS)z Construct a TensorArrayElement from a NumPy ndarray. Args: values: ndarray that underlies this TensorArray element. Nrr-r;s r.rszTensorArrayElement.__init__1s r0c4|jSrYrrrvs r.rzTensorArrayElement.__repr__:|$$&&&r0c4|jSrYrrrvs r.rzTensorArrayElement.__str__=|##%%%r0c|jjSzf Get the dtype of the tensor. :return: The numpy dtype of the backing ndarray rrnrvs r. numpy_dtypezTensorArrayElement.numpy_dtype@ |!!r0c|jjSzl Get the number of tensor dimensions. :return: integer for the number of dimensions rr@rvs r. numpy_ndimzTensorArrayElement.numpy_ndimH |  r0c|jjSz~ Get the shape of the tensor. :return: A tuple of integers for the numpy shape of the backing ndarray rrGrvs r. numpy_shapezTensorArrayElement.numpy_shapePrr0c|jjSzo Get the size of the tensor. :return: integer for the number of elements in the tensor rsizervs r. numpy_sizezTensorArrayElement.numpy_sizeXrr0c4tj|jS)zG Return the values of this element as a NumPy ndarray. r>r?rrvs r.rzTensorArrayElement.to_numpy`sz$,'''r0Nrnrc 4tj|jfd|i|SNrnrr-rnkwargss r. __array__zTensorArrayElement.__array__f!z$,>>e>v>>>r0rY)rrrrr>ndarrayrsrrrrrrrrrnrr~r0r.ruru+srz'''&&&""X"!!X!""X"!!X!((( ??rx?RZ??????r0ruc eZdZdZejejejejej ej ej ej ej ejd ZdeejeeeejefeeffdZeddddeed efd Zedejd ejjjfd Z d ee!e"ejfdedfdZ#de!fdZ$e%dejjj&fdZ'e%dZ(e%de!fdZ)d7dZ* d8dee!dededdfdZ+d7dZ,ededddfdZ-dee!ejfdeddfdZ.deffd Z/d!Z0d"Z1de2ejeffd#Z3d9d%e4d&efd'Z5d:dej'dejfd(Z6d)e7d*e4fd+Z8ddejjj9fdej'd ed,efd-Z:e%d.Z;e%d/Zd9d2Z?d;d3Zd;d4Zd:d5Z@e%d6ZAxZBS)>> # Create a DataFrame with a list of ndarrays as a column. >>> import pandas as pd >>> import numpy as np >>> import ray >>> from ray.data.extensions import TensorArray >>> df = pd.DataFrame({ ... "one": [1, 2, 3], ... "two": TensorArray(np.arange(24).reshape((3, 2, 2, 2)))}) >>> # Note that the column dtype is TensorDtype. >>> df.dtypes # doctest: +SKIP one int64 two TensorDtype(shape=(3, 2, 2, 2), dtype=int64) dtype: object >>> # Pandas is aware of this tensor column, and we can do the >>> # typical DataFrame operations on this column. >>> col = 2 * (df["two"] + 10) >>> # The ndarrays underlying the tensor column will be manipulated, >>> # but the column itself will continue to be a Pandas type. >>> type(col) # doctest: +SKIP pandas.core.series.Series >>> col # doctest: +SKIP 0 [[[ 2 4] [ 6 8]] [[10 12] [14 16]]] 1 [[[18 20] [22 24]] [[26 28] [30 32]]] 2 [[[34 36] [38 40]] [[42 44] [46 48]]] Name: two, dtype: TensorDtype(shape=(3, 2, 2, 2), dtype=int64) >>> # Once you do an aggregation on that column that returns a single >>> # row's value, you get back our TensorArrayElement type. >>> tensor = col.mean() # doctest: +SKIP >>> type(tensor) # doctest: +SKIP ray.data.extensions.tensor_extension.TensorArrayElement >>> tensor # doctest: +SKIP array([[[18., 20.], [22., 24.]], [[26., 28.], [30., 32.]]]) >>> # This is a light wrapper around a NumPy ndarray, and can easily >>> # be converted to an ndarray. >>> type(tensor.to_numpy()) # doctest: +SKIP numpy.ndarray >>> # In addition to doing Pandas operations on the tensor column, >>> # you can now put the DataFrame into a Dataset. >>> ds = ray.data.from_pandas(df) # doctest: +SKIP >>> # Internally, this column is represented the corresponding >>> # Arrow tensor extension type. >>> ds.schema() # doctest: +SKIP one: int64 two: extension> >>> # You can write the dataset to Parquet. >>> ds.write_parquet("/some/path") # doctest: +SKIP >>> # And you can read it back. >>> read_ds = ray.data.read_parquet("/some/path") # doctest: +SKIP >>> read_ds.schema() # doctest: +SKIP one: int64 two: extension> >>> read_df = ray.get(read_ds.to_pandas_refs())[0] # doctest: +SKIP >>> read_df.dtypes # doctest: +SKIP one int64 two TensorDtype(shape=(3, 2, 2, 2), dtype=int64) dtype: object >>> # The tensor extension type is preserved along the >>> # Pandas --> Arrow --> Parquet --> Arrow --> Pandas >>> # conversion chain. >>> read_df.equals(df) # doctest: +SKIP True ) sumranyminmaxmeanmedianprodstdvarr;c^t|trt|}not|trd|D}t|}n>t|tr)t jt j|gd}t|t jr|j j t j urot|dkrntd|Drd|D}t|}nstdt|ddnLt|trtd td |d t|jd t|t jsJ||_d |_d S)zy Args: values: A NumPy ndarray or sequence of NumPy ndarrays of equal shape. cdg|]-}t|trtj|n|.Sr~r:rur>r?rr^s r.rz(TensorArray.__init__..sD",A/A!B!BI 1 r0Fcopyrc3K|]A}t|tjttfot|t  VBdSrY)r:r>rrurr[rs r.rz'TensorArray.__init__..saq2:/A8"LMM/&q#...r0c6g|]}tj|Sr~)r>r?rs r.rz(TensorArray.__init__..s <<<bjmm<<rHr?rrnrwobject_rrrr<rr_is_variable_shapedrs r.rszTensorArray.__init__s" fi ( ( @4V<rrr<r)rscalarsrnrs r._from_sequencezTensorArray._from_sequencesp.  JJw 33 JllnnGG  - - J04Igo**,,,'/G7###r0originalct)a Reconstruct an ExtensionArray after factorization. Parameters ---------- values : ndarray An integer ndarray with the factorized values. original : ExtensionArray The original ExtensionArray that factorize was called on. See Also -------- factorize : Top-level factorize method that dispatches here. ExtensionArray.factorize : Encode the extension array as an enumerated type. r)rr;r!s r._from_factorizedzTensorArray._from_factorized,s ("!r0itemr)r<ruct|tr2|j|}tj|r|St |St|t rNt|dkr;|dtkr*t|dkrtd|d}t|trtj |}t||}t|j|S)aA Select a subset of self. Parameters ---------- item : int, slice, or ndarray * int: The position in 'self' to get. * slice: A slice object, where 'start', 'stop', and 'step' are integers or None * ndarray: A 1-d boolean NumPy ndarray the same length as 'self' Returns ------- item : scalar or ExtensionArray Notes ----- For scalar ``item``, return a scalar value suitable for the array's type. This should be an instance of ``self.dtype.type``. For slice ``key``, return an instance of ``ExtensionArray``, even if the slice is length 0 or 1. For a boolean mask, return an instance of ``ExtensionArray``, filtered to the values where ``item`` is True. rrzCWorkaround Pandas issue #42430 not implemented for tuple length > 2) r:rrr>rrutuplerEllipsis ValueErrorr<r?r)r-r%values r. __getitem__zTensorArray.__getitem__Bs: dC  3L&E{5!! 1 )%000$&& 3t99q==T!W=P=Pt99q==$;Aw$ ,, (z$''&tT22Dt|D122 2r0c*t|jS)z] Length of this array. Returns ------- length : int )rrrvs r.__len__zTensorArray.__len__us4<   r0c|jr(|jdj}d|jdjz}n|j}|jdd}t ||S)z2 An instance of 'ExtensionDtype'. rrYrN)rrrnr@rrrm)r-rnrGs r.rnzTensorArray.dtypes]  " )LO)Edl1o22EE$E$QRR(E5%(((r0cP|jt|j|_|jS)zQ Whether this TensorArray holds variable-shaped tensor elements. )rrrrvs r.rzTensorArray.is_variable_shapeds(  # +'I$,'W'WD $''r0c|jjS)zL The number of bytes needed to store this object in memory. )rnbytesrvs r.r2zTensorArray.nbytess |""r0c &jjjtjurAtjfdt tDtSjjjtj urDtj jdktt djj Stj tj jtt djj S)a A 1-D array indicating if each value is missing. Returns ------- na_values : Union[np.ndarray, ExtensionArray] In most cases, this should return a NumPy ndarray. For exceptional cases like ``SparseArray``, where returning an ndarray would be expensive, an ExtensionArray may be returned. Notes ----- If returning an ExtensionArray, then * ``na_values._is_boolean`` should be True * `na_values` should implement :func:`ExtensionArray._reduce` * ``na_values.any`` and ``na_values.all`` should be implemented c.g|]}j|duSrYr)rir-s r.rz$TensorArray.isna..s$CCCQaD(CCCr0rnraxis)rrnrwr>rrHrangerboolstr_rr(r@isnanrvs`r.isnazTensorArray.isnas( <  "bj 0 08CCCC%D 2B2BCCC4 \  $ / /6$,",5q$,BS9T9T3U3UVVV V6&&U5DLr?intprrrr nanfullrGputwherer<take)r-r?r@rA has_missingr; is_nonnegs r.rHzTensorArray.takes d  +j888G Wc$,&7&7 8 8 8&1--K +%!#J#g,,4<3Eabb3I!I:VV$qL vrx 2215t|GIDV7WXXX"6***""7"336"""r0cNt|jS)ze Return a copy of the array. Returns ------- ExtensionArray )r<rrrvs r.rzTensorArray.copy,s 4<,,..///r0 to_concatc*d}d}|D]+}| |jj}|js|jj|krd}n,|r3tt jd|Dt }n+tt jd|D}|S)z Concatenate multiple array of this dtype. Parameters ---------- to_concat : sequence of this type Returns ------- ExtensionArray FNTc&g|]}|jD]}|Sr~r)raes r.rz1TensorArray._concat_same_type..Ns'BBB BB1!BBBBr0r6cg|] }|j Sr~r)rrOs r.rz1TensorArray._concat_same_type..Qs2P2P2P192P2P2Pr0)rnr{rr<r>rHobjectr)rrLshould_flattenrGrOconcateds r._concat_same_typezTensorArray._concat_same_type7s  A}-# qw'<'E'E!%(F  S"BBYBBB&QQQHH#2>2P2Pi2P2P2P#Q#QRRHr0keyr+ct||}t|tstj|rtj|}t|t r d|D}t|tr!t|jtr|j }|(t|trGt|dkr4tj |j|tj|j|<dSt|t t"tjfr ||j|<dSt'dt)|d)a^ Set one or more values inplace. This method is not required to satisfy the pandas extension array interface. Parameters ---------- key : int, ndarray, or slice When called from, e.g. ``Series.__setitem__``, ``key`` will be one of * scalar int * ndarray of integers. * boolean ndarray * slice object value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object value or values to be set of ``key``. Returns ------- None cdg|]-}t|trtj|n|.Sr~rrs r.rz+TensorArray.__setitem__..qsANOA/A!B!BI 1 r0Nrz__setitem__ with key type 'z' not implemented)rr:rur>rr?listrrnrmr;rr full_likerrDrslicerrrw)r-rVr+s r. __setitem__zTensorArray.__setitem__Ts?2"$,, e/ 0 0 &BK4F4F &Ju%%E eT " " SXE eY ' ' !Ju{K,P,P !LE =Juh77=CJJ!OO " T\#-> G GDL    c5"*5 6 6  %DL   %Jd3iiJJJ r0cFt|trktj|}|jdkrLtj|r&|St |S)z, Return for `item in self`. r) r:rur>r?rr=rr>r super __contains__)r-r%np_item __class__s r.r_zTensorArray.__contains__s d. / / )j&&G|q  RXg%6%6%:%:%<%< yy{{(((ww##D)))r0c4|jSrYrrvs r.rzTensorArray.__repr__rr0c4|jSrYrrvs r.rzTensorArray.__str__rr0ctrYr#rvs r._values_for_factorizez!TensorArray._values_for_factorizes!!r0Trskipnac dg}i}|D]} ||||<#t$rYwxYw t|j||jfddi|S#t$rt d|ddwxYw)a Return a scalar result of performing the reduction operation. Parameters ---------- name : str Name of the function, supported values are: { any, all, min, max, sum, mean, median, prod, std, var, sem, kurt, skew }. skipna : bool, default True If True, skip NaN values. **kwargs Additional keyword arguments passed to the reduction function. Currently, `ddof` is the only supported kwarg. Returns ------- scalar Raises ------ TypeError : subclass does not define reductions ddofr9r'z' aggregate not implemented.N)KeyErrorruSUPPORTED_REDUCERSrr)r-rrfrsupported_kwargsreducer_kwargskws r._reducezTensorArray._reduces0#8"  B %+BZr""     X%-'-dlUUUnUU  X X X%&L$&L&L&LMMSW W Xs  $$'AA/c 4tj|jfd|i|Srrrs r.rzTensorArray.__array__rr0ufuncmethodc|dd}||zD]7}t|ttjt jfs tcS8td|D}|rtd|D|d<t|||i|}t|turtfd|DS|dkrdSt|S)z` Supports NumPy ufuncs without requiring sloppy coercion to an ndarray. outr~c3RK|]"}t|tr|jn|V#dSrYr:r<rrr\s r.rz.TensorArray.__array_ufunc__..s7VV!Jq+$>$>EqyyAVVVVVVr0c3RK|]"}t|tr|jn|V#dSrYrvrws r.rz.TensorArray.__array_ufunc__..sH""CDZ;77> Q""""""r0c3HK|]}t|VdSrY)rw)rr\r-s r.rz.TensorArray.__array_ufunc__..s1771dA777777r0atN) getr:r<r>rnumbersNumberrr(getattrrw)r-rqrrinputsrrtr\rs` r.__array_ufunc__zTensorArray.__array_ufunc__s( jj### & &Aa+rz7>!JKK &%%%% &VVvVVVVV  !""HK"""F5M('':6:: <<5 777777777 7 t^^44::f%% %r0na_valuec |^tjj|}|rt j|j|d}n>|j|}n#|r|j}n|j}|S)aj Convert to a NumPy ndarray. .. versionadded:: 1.0.0 This is similar to :meth:`numpy.asarray`, but may provide additional control over how the conversion is done. Parameters ---------- dtype : str or numpy.dtype, optional The dtype to pass to :meth:`numpy.asarray`. copy : bool, default False Whether to ensure that the returned value is a not a view on another array. Note that ``copy=False`` does not *ensure* that ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that a copy is made, even if not strictly necessary. na_value : Any, optional The value to use for missing values. The default value depends on `dtype` and the type of the array. Returns ------- numpy.ndarray NTr) pdapitypes pandas_dtyper>rHrastyper)r-rnrrr;s r.rzTensorArray.to_numpys>  FL--e44E 4$,e$GGG,,U33  "\&&((FF\F r0c|jjSrrrvs r.rzTensorArray.numpy_dtyperr0c|jjSrrrvs r.rzTensorArray.numpy_ndim rr0c|jjSrrrvs r.rzTensorArray.numpy_shaperr0c|jjSrrrvs r.rzTensorArray.numpy_sizerr0c`tjj|}t |t r,|r&t |jn|}nHtjj |r$tjj |shtj d|jD}t |tj r)||dS|Stjj |rXtjt#|t$}t't#|D]}|j|||<n|j||}|S)a Cast to a NumPy array with 'dtype'. Parameters ---------- dtype : str or dtype Typecode or data-type to which the array is cast. copy : bool, default True Whether to copy the data, even if not necessary. If False, a copy is made only if the old dtype does not match the new dtype. Returns ------- array : ndarray NumPy ndarray with 'dtype' for its dtype. c,g|]}t|Sr~rZ)rts r.rz&TensorArray.astype..<s<<rH StringDtyperr emptyrrRr:r)r-rnrr;r5s r.rzTensorArray.astype#sr$ ))%00 e[ ) ) ;9=G[!2!2!4!45554FF FL ( ( / / ;46FL4P4PQV4W4W ;X<+>>r0cb|j|||}||nt|S)a Test whether all array elements along a given axis evaluate to True. :param axis: Axis or axes along which a logical AND reduction is performed. :param out: Alternate output array in which to place the result. :param keepdims: If this is set to True, the axes which are reduced are left in the result as dimensions with size one. :return: single boolean unless axis is not None else TensorArray r)rrr<rs r.rzTensorArray.all[s6!!tx!HHvv;v+>+>>r0cddlm}m}|jr||jS||jS)a Convert this TensorArray to an ArrowTensorArray extension array. This and TensorDtype.__from_arrow__ make up the Pandas extension type + array <--> Arrow extension type + array interoperability protocol. See https://pandas.pydata.org/pandas-docs/stable/development/extending.html#compatibility-with-apache-arrow for more information. r)ArrowTensorArrayArrowVariableShapedTensorArray)$ray.air.util.tensor_extensions.arrowrrr from_numpyr)r-rwrrs r.__arrow_array__zTensorArray.__arrow_array__isc         " =1<r rr r r r rrrrrkr rrrrurrsrrr r;r rr extensionsExtensionArrayr$rr[r,r.rExtensionDtypernrr2r>rHrrUr\r_rrrrer[rorrr no_defaultrrrrrrrr __classcell__)ras@r.r<r<js SSlvvvvv)vv  9( J  U2:'99: ;     9(9(9(9(v26U$$$ ($>B$$$[$8"Z"+-6+<+K"""["*13#ubj0113 2 313131313f!!!!! )rv(7 ) ) )X )((X(####X# DSWk#k#}k#26k#LOk# k#k#k#k#Z 0 0 0 0(=*Am[8)uS"*_5)c)d))))V*D******'''&&&"uRZ_'=""""$X$XC$X$X$X$X$XL??rx?RZ????&X&s&&&&<)4 ))x)) ))))V""X"!!X!""X"!!X!%%%%N????" ? ? ? ?====(((X(((((r0r<sc|jjtjuo,|j o$t |jdtjS)aReturn whether the provided pandas Series column needs a tensor extension representation. This tensor extension representation provides more efficient slicing and interop with ML frameworks. Args: s: The pandas Series column that may need to be represented using the tensor extension. Returns: Whether the provided Series needs a tensor extension representation. r)rnrwr>rrr:ilocr)rs r.column_needs_tensor_extensionrs7   "X17{Xz!&)RZ7X7Xr0)Br|ostypingrrrrrrr numpyr>pandasrpyarrowrpackaging.versionr pandas._typingr pandas.compatr pandas.core.dtypes.genericr rpandas.core.indexersrr$ray.air.util.tensor_extensions.utilsrrray.util.annotationsrr ImportErrorrr[rMre_FORMATTER_ENABLED_ENV_VARgetenv __version__r9rh formatter_clsri_format_stringsr=_patched_by_ray_datasetsrrregister_extension_dtyperrmExtensionScalarOpsMixinrrrurr<_add_arithmetic_ops_add_comparison_ops_add_logical_opsSeriesr;rr~r0r.rsB HHHHHHHHHHHHHHHHHH%%%%%% ++++++>>>>>>>>FFFFFFFF+*****E3333333EEEDDDDDDDDE'.T#Y'.'.'.'.T9>DI9>9>9>9>xI 29 '--44wr~!1!111DDDDDD/ EEEEEE0 )6)FM&ww772>22EEEEWWW5E5EEEEEE(? %%(F %-1M* V+[*[*[*[*[*"&#2[*[*,+[*|3&3&3&3&3&bf'?3&3&3&l%%%%%%%%0 V;?;?;?;?;?*@;?;?;?| Vc (c (c (c (c (F$c (c (c (P&&(((&&(((##%%% !!! !!!  VRY4sA A-,A-