bim UdZddlZddlZddlZddlZddlmZmZddlmZ ddlmZ ddl m Z m Z mZmZddlmZmZddlmZddlmZmZmZmZmZmZddlZddlZddl Z!ddl"m#Z$ddl%Z dd l&m'Z(dd l&m)Z*d d l+m,Z,d d l-m.Z.m/Z/d dl0m1Z1d dl2m3Z3m4Z4d dl5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mm?Z?m@Z@ddlAmBZBmCZCddlDmEZEe4jeGZHde!jdeJfdZKdeJde!jfdZLdedeMdeMdeNeeMffdZOdvdedefd!ZPe d "Gd#d$ZQGd%d&ZRe Gd'd(eRZSe Gd)d*eRZTe Gd+d,eRZUe Gd-d.eRZVGd/d0e!jZXGd1d2eXZYGd3d4eXZZGd5d6eXZ[Gd7d8eXZ\e!jeYd9d:e!jeZd;d:e!je[de!jd?eMdeMfd@Z^GdAdBe!jNZ_GdCdDe*Z`GdEdFe(ZadGZbe GdHdIZcGdJdKZe d "GdLdMeZde d "GdNdOZeeefegeNeQeceBeCeeedeSeTeUeVe:ee!jdehfd[Zrdxd\ejd]e!jde!jfd^Zud_egee!jde!jfd`Zwdxd_egejd]e!jde!jfdaZxdbefdcZydxdbeejegfd]e!jde!jfddZzdbed>eXde!jfdeZ{dfehdgeehgeehfdehfdhZ|egeeJedfZ}gfdfehdgeehe}geehfdie}dehfdjZ~dwdfehdkeMdeMfdlZdfehdeMfdmZdfehdeMfdnZdoZGdpdqefZdregedegefdsZdregefdtZdfedehfduZy)zz[This class handle features definition in datasets and some utilities to display table type.N)IterableMapping)Sequence)InitVar dataclassfieldfields)reducewraps)mul)AnyCallableClassVarLiteralOptionalUnion)ExtensionArray)ExtensionDtype)config)camelcase_to_snakecasesnakecase_to_camelcase) array_cast) experimentallogging)asdictfirst_non_null_valuezip_dict)Audio)Imageencode_pil_image)Pdfencode_pdfplumber_pdf) TranslationTranslationVariableLanguages)Video arrow_typereturnctjj|rytjj|rytjj |rytjj |rytjj |rytjj|rytjj|rytjj|rytjj|ry tjj|ry tjj|ry tjj|ry tjj|ry tjj|r,dt!j"t%|j&dStjj)|r,dt!j"t%|j&dStjj+|rT|j,d|j&dS|j,rd|j&d|j,dSt/d|dtjj1|rytjj3|rytjj5|rd|j&dStjj7|rd|j8d|j:dStjj=|rd|j8d|j:dStjj?|rytjjA|rytjjC|rytjjE|rytjjG|ry tjjI|rtK|jLSt/d!|d")#z _arrow_to_datasets_dtype takes a pyarrow.DataType and converts it to a datasets string dtype. In effect, `dt == string_to_arrow(_arrow_to_datasets_dtype(dt))` nullboolint8int16int32int64uint8uint16uint32uint64float16float32float64ztime32[]ztime64[z timestamp[z, tz=zUnexpected timestamp object .date32date64z duration[z decimal128(, )z decimal256(binary large_binarystring large_string string_viewz Arrow type z+ does not have a datasets dtype equivalent.)'pyarrowtypesis_null is_booleanis_int8is_int16is_int32is_int64is_uint8 is_uint16 is_uint32 is_uint64 is_float16 is_float32 is_float64 is_time32patype_for_aliasstrunit is_time64 is_timestamptz ValueError is_date32 is_date64 is_duration is_decimal128 precisionscale is_decimal256 is_binaryis_large_binary is_stringis_large_stringis_string_view is_dictionary_arrow_to_datasets_dtype value_type)r(s U/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/datasets/features/features.pyrhrh5sH }}Z(  ! !* -   z *    +    +    +    +   ,   ,   ,  ! !* -  ! !* -  ! !* -   ,**3z?;@@ACC   ,**3z?;@@ACC  # #J / ==  02 2 ]] 0jmm_AF F;J>;zl2]^__datasets_dtypec d0d}|tjvrtj|S|dztjvrtj|dzStjd|}|r|j d}tjd|}|dvrtj |S|r4tj |j d|j dSt ||dd d gd g tjd |}|rB|j d}|dvrtj|St ||dddgdg tjd|}|r|j d}|dk(r8|j d} | dvrtj| St | d|dk(r8|j d} | dvrtj| St | dt ||dddgddg tjd|} | rF| j d} | dk(rtjd | j d} | rJ| j d} | j d}tjt| t|St ||d!d"d#gd$g | d%k(rtjd | j d} | rJ| j d} | j d}tjt| t|St ||d&d'd(gd)g t ||d*d+d,gd$d)g t d-|d.|dzd/)1a string_to_arrow takes a datasets string dtype and converts it to a pyarrow.DataType. In effect, `dt == string_to_arrow(_arrow_to_datasets_dtype(dt))` This is necessary because the datasets.Value() primitive type is constructed using a string dtype Value(dtype=str) But Features.type (via `get_nested_type()` expects to resolve Features into a pyarrow Schema, which means that each Value() must be able to resolve into a corresponding pyarrow.DataType, which is the purpose of this function. c|d|d}|r9t|dkDrdj|dddz|dzn|d}|d|d z }|r9t|dkDrdj|ddd z|dzn|d}|d |d z }|S) NzA is not a validly formatted string representation of the pyarrow z type.rr<z or rz Valid examples include: r9 and z For more insformation, see: )lenjoin)dtypepa_dtypeexamplesurlsmsgs rj_dtype_error_msgz)string_to_arrow.._dtype_error_msgsXYaXbbhi KNx=[\K\tyy#2/&88B<GbjklbmH /z; ;C @CD A 499T#2Y''1DH*,,,{{>C/022 "8.I/55a8II&RTgh "9 9<< 34 4 << 1 7 7 :SUdUjUjklUm4n 14AGGJ =CCAF}}S^SZ@@ $&$"57J!Kfg $u ,46II>SUdUjUjklUm4n 14AGGJ =CCAF}}S^SZ@@ $&$"57K!Lfg  "13FG``     >"%(<'=>T U rkobjonly_1d_for_numpyoptimize_list_castingc ntjrdtjvrddl}tj rdtjvrddl}tjrdtjvrddlm }tjrdtjvrddl }tjrdtjvrddl }tjrdtjvrdd lm}m} t%|t&j(rL|j*dk(r|d d fS|r|j*d k(r|d fS|D cgc]} t-| ||dc} d fStj rcdtjvrPt%|j.r9|j0|j2k(rVt-|j5j7|j8j;j||dd fS|j*dk(r1|j5j;jd d fS|r|j*d k(r.|j5j;jd fS|j5j;jD cgc]} t-| ||dc} d fStjrdtjvrt%|j.rv|j*dk(r|jd d fS|r|j*d k(r|jd fS|jD cgc]} t-| ||dc} d fStjrdtjvrt%|j(r|j*dk(rt'j<|d d fS|r|j*d k(rt'j<|d fSt'j<|D cgc]} t-| ||dc} d fStjr?dtjvr-t%|j>j>r tA|d fStjr?dtjvr-t%|jBjDr tG|d fSt%|tHjJr!t-|jM||dd fSt%|tHjNrD|jQdjSD cic]\} } | t-| ||dc} } d fSt%|tHjTr|jWd fSt%|tHjXr|j[d fSt%|t\rPt%|t^ } i}|jSD] \}}t-|||\}}| |z} |||<"| r|| fS|| fSta|dr:t'jb|r|d fSt-|je||dd fSt%|tfthfrtk|dkDrq|D]}tm|snt-||\}}|s|s!|Dcgc]}t-|||dc}d fSt%|tfthfr|d fStg|d fS|d fStjr;dtjvr)t%| rto}|jq|d fStjr;dtjvr)t%|rts}|jq|d fS|d fScc} wcc} wcc} wcc} wcc} } wcc}w)a Cast pytorch/tensorflow/pandas objects to python numpy array/lists. It works recursively. If `optimize_list_casting` is True, to avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be casted. If the first element needs to be casted, then all the elements of the list will be casted, otherwise they'll stay the same. This trick allows to cast objects that contain tokenizers outputs without iterating over every single token for example. Args: obj: the object (nested struct) to cast. only_1d_for_numpy (bool): whether to keep the full multi-dim tensors as multi-dim numpy arrays, or convert them to nested lists of 1-dimensional numpy arrays. This can be useful to keep only 1-d arrays to instantiate Arrow arrays. Indeed Arrow only support converting 1-dimensional array values. optimize_list_casting (bool): whether to optimize list casting by checking the first non-null element to see if it needs to be casted and if it doesn't, not checking the rest of the list elements. Returns: casted_obj: the casted object has_changed (bool): True if the object has been changed, False if it is identical tensorflowrNtorchjaxPIL pdfplumber torchcodec) AudioDecoder VideoDecoderTrFrrseries __array__):r TF_AVAILABLEsysmodulesrTORCH_AVAILABLEr JAX_AVAILABLE jax.numpynumpy PIL_AVAILABLE PIL.ImagePDFPLUMBER_AVAILABLErTORCHCODEC_AVAILABLEtorchcodec.decodersrr isinstancenpndarrayndim_cast_to_python_objectsTensorrsbfloat16detachtofloatcpuasarrayr!r"pdfPDFr$pdSeriestolist DataFrameto_dictitems Timestamp to_pydatetime Timedeltato_pytimedeltardicthasattrisscalarrlisttuplerq#_check_non_null_non_empty_recursiver'encode_exampler )rrrtfrjnprrrrxkeyvalue has_changedoutputkvcasted_v has_changed_v first_elmtcasted_first_elmthas_changed_first_elmtelmtas rjrrs:,|s{{: 'S[["8  4  4 ""|s{{'B ""|s{{'BB#rzz" 88q=r7D= "chh!m: ! ,->Vk     Gs{{$:z#u||?\ 99 &*  ,00288:"3&;    88q=::<##%++-b147 7"chh!m::<##%++-t3 3!ZZ\--/557 ,->Vk     !<CQSQZQZA[ 88q=99;r?D( ("chh!m99;$ $!YY[ ,->Vk     %3;;"6:c3;;;W 88q=::c?2&, ,"chh!m::c?D( ( ZZ_ ,->Vk     %3;;"6:c399??;[$d**  $ $)DTWYcYgYgYkYkIl$S)4// C # # 0AYn      C & #&++h"7"="="?  C,->Vk     C &  "D(( C &!!#T)) C !$S$// IIK !DAq&=%6Nc' #Hm = (K F1I  ! %v{::#{:: k " ;;s : (MMO7H`u   C$ ' s8a<!  6zB 9P.?Wl9 5 5&-B %( !0 4E]r cD%=1:%9d?*:   $ $)DTWYeIf G$d**  $ $)DTWYeIf G$d**EzQ** Ts$4^(^^"^'^,6^2Fc$t|||dS)a Cast numpy/pytorch/tensorflow/pandas objects to python lists. It works recursively. If `optimize_list_casting` is True, To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be casted. If the first element needs to be casted, then all the elements of the list will be casted, otherwise they'll stay the same. This trick allows to cast objects that contain tokenizers outputs without iterating over every single token for example. Args: obj: the object (nested struct) to cast only_1d_for_numpy (bool, default ``False``): whether to keep the full multi-dim tensors as multi-dim numpy arrays, or convert them to nested lists of 1-dimensional numpy arrays. This can be useful to keep only 1-d arrays to instantiate Arrow arrays. Indeed Arrow only support converting 1-dimensional array values. optimize_list_casting (bool, default ``True``): whether to optimize list casting by checking the first non-null element to see if it needs to be casted and if it doesn't, not checking the rest of the list elements. Returns: casted_obj: the casted object rr)r)rrrs rjcast_to_python_objectsrs"( # 0H]   rk)reprceZdZUdZeed<eddZeeed<dZ e e ed<edddZ eed <d Z d Zd Zd Zy)Valuea Scalar feature value of a particular data type. The possible dtypes of `Value` are as follows: - `null` - `bool` - `int8` - `int16` - `int32` - `int64` - `uint8` - `uint16` - `uint32` - `uint64` - `float16` - `float32` (alias float) - `float64` (alias double) - `time32[(s|ms)]` - `time64[(us|ns)]` - `timestamp[(s|ms|us|ns)]` - `timestamp[(s|ms|us|ns), tz=(tzstring)]` - `date32` - `date64` - `duration[(s|ms|us|ns)]` - `decimal128(precision, scale)` - `decimal256(precision, scale)` - `binary` - `large_binary` - `string` - `large_string` - `string_view` Args: dtype (`str`): Name of the data type. Example: ```py >>> from datasets import Features >>> features = Features({'stars': Value('int32')}) >>> features {'stars': Value('int32')} ``` rsNFdefaultridpa_typerinitr_typec|jdk(rd|_|jdk(rd|_t|j|_y)Ndoubler7rr6)rsrrselfs rj __post_init__zValue.__post_init__s8 :: !"DJ :: "DJ&tzz2 rkc|jSNrrs rj__call__zValue.__call__ ||rkcvtjj|jr t |Stjj |jr t |Stjj|jr t|Stjj|jr t|Stjj|jr t|Stjj|jr t|S|Sr) rSrDrFrr, is_integerr is_floatingrrdrUrerfrrs rjrzValue.encode_example!s 88  t|| ,;  XX  .u:  XX ! !$,, /<  XX   -u:  XX % %dll 3u:  XX $ $T\\ 2u: LrkcLt|jd|jdS)Nz('z'))type__name__rsrs rj__repr__zValue.__repr__1s$t*%%&b B77rk)r __module__ __qualname____doc__rU__annotations__rrrrrr rrrrrrrkrjrrsY,\ Jd7B 7!GXc]!wU?E3?3 8rkrceZdZdZdZdZy)_ArrayXDc8t|j|_yr)rshapers rjrz_ArrayXD.__post_init__6s4::& rkct|jjdz|j|j}|S)N ExtensionType)globals __class__rr rs)rrs rjrz_ArrayXD.__call__9s6F')DNN33oEFtzzSWS]S]^rkc|Srrrs rjrz_ArrayXD.encode_example=s rkN)rrrrrrrrkrjr r 5s'rkr cjeZdZUdZeed<eed<eddZe eed<edddZ eed <y) Array2Da6Create a two-dimensional array. Args: shape (`tuple`): Size of each dimension. dtype (`str`): Name of the data type. Example: ```py >>> from datasets import Features >>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')}) ``` r rsNFrrrr rrrrrrrUrrrrrrkrjrrA; L Jd7B 7yu5AE3ArkrcjeZdZUdZeed<eed<eddZe eed<edddZ eed <y) Array3Da;Create a three-dimensional array. Args: shape (`tuple`): Size of each dimension. dtype (`str`): Name of the data type. Example: ```py >>> from datasets import Features >>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')}) ``` r rsNFrrrrrrrkrjrrZrrkrcjeZdZUdZeed<eed<eddZe eed<edddZ eed <y) Array4Da=Create a four-dimensional array. Args: shape (`tuple`): Size of each dimension. dtype (`str`): Name of the data type. Example: ```py >>> from datasets import Features >>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')}) ``` r rsNFrrrrrrrkrjrrsrrkrcjeZdZUdZeed<eed<eddZe eed<edddZ eed <y) Array5Da@Create a five-dimensional array. Args: shape (`tuple`): Size of each dimension. dtype (`str`): Name of the data type. Example: ```py >>> from datasets import Features >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')}) ``` r rsNFrrrrrrrkrjrrrrkrcfeZdZUdZeeed<dedefdZ dZ e dZ dZ d Zd Zd Zd Zy) _ArrayXDExtensionTypeNndimsr rsc2|j|jdkr tdt||jk7rtd|d|jdtd|jD]}|| td|t ||_||_|j|j |_tjj||j|jjd|jjy)NrzCYou must instantiate an array type with a value for dim that is > 1zshape=z and ndims=z don't matchz3Support only dynamic size on first dimension. Got: r9)rrZrqrangerr ri_generate_dtype storage_dtyperSr __init__rrr)rr rsdims rjr"z_ArrayXDExtensionType.__init__s :: qbc c u: #veWK |<PQ QDJJ' `CSz! #VW\V]!^__ `5\ !11$//B !!$(:(:t~~?X?X>YYZ[_[i[i[r[rZsrrkrjrrs[E8C= ve vC vB cC#:rkrceZdZdZy)Array2DExtensionTyperNrrrrrrkrjrArA ErkrAceZdZdZy)Array3DExtensionTypeNrBrrkrjrErErCrkrEceZdZdZy)Array4DExtensionTypeNrBrrkrjrHrHrCrkrHceZdZdZy)Array5DExtensionTypeNrBrrkrjrKrKrCrkrK)rrr0)rrrF)rrrFrI)rrrFrIrLrunnestc(dtjdtjffd |r|}tjj|xrAtjj |xstjj | S)a When converting a pyarrow array to a numpy array, we must know whether this could be done in zero-copy or not. This function returns the value of the ``zero_copy_only`` parameter to pass to ``.to_numpy()``, given the type of the pyarrow array. # zero copy is available for all primitive types except booleans and temporal types (date, time, timestamp or duration) # primitive types are types for which the physical representation in arrow and in numpy # https://github.com/wesm/arrow/blob/c07b9b48cf3e0bbbab493992a492ae47e5b04cad/python/pyarrow/types.pxi#L821 # see https://arrow.apache.org/docs/python/generated/pyarrow.Array.html#pyarrow.Array.to_numpy # and https://issues.apache.org/jira/browse/ARROW-2871?jql=text%20~%20%22boolean%20to_numpy%22 rr)cjtjj|r|jS|Sr)rSrDis_listri)r_unnest_pa_types rjrQz+_is_zero_copy_only.._unnest_pa_types+ 88  G $"7#5#56 6rk)rSDataTyperD is_primitiverF is_temporal)rrMrQs @rj_is_zero_copy_onlyrUsq !'* 88  ) q2883F3Fw3O3pSUS[S[SgSghoSp.qqrkc:eZdZdZdZddZd deedfdZy) r6cht|jjd}|j|SNTrMzero_copy_only)rUstoragerto_numpy)rr[s rjrzArrayExtensionArray.__array__s)+DLL,=,=dK}}N};;rkc |j|Sr)r\)ris rj __getitem__zArrayExtensionArray.__getitem__s||Arkc |j}|jjd}|jjd;d}t j t||t j t j|z }t|jjD].}||jj|z}|j}0|j|}|jt|t|z g|jj}t|rDt j|jt j|t j d}|S|jj}|jj} g} t j"|j$D cgc]} | j'c} } t)|D]\}} | r | j+t j (|||dz}| |dz| |z }t| D]}|j}|j|}| j+|j|g|ddtt j,t j.| dkDr+t j0t| t2}| |dd|St j"| }|Scc} w)NFrZrraxisrs)r\rEr]rr rarangerqsumrrflattenreshapeinsertastyper7nanarrayoffsetsas_py enumerateappenduniquediffemptyobject)rr[r\ null_masksize null_indicesr_ numpy_arrr rarraysofffirst_dim_offsetsrE storage_el first_dimrys rjr]zArrayExtensionArray.to_numpys $ OO%..e.D 99??1  )D99S\29= "&&QZJ[@\\L499??+ , **!//+ , (((GI) ))#d)c,6G*GZ$))//ZI< IIi&6&6rzz&BLRTRXRX_`a 61IIOOEIIOOEF ")Q##))+)Q R ' 2 L 7MM"&&)!(QU!3J 1!a% 8;LQ;O OI"5\:%/%7%7%9 :!+ 3 3> 3 RIMM"3)"3"3I"Jab "JK L299RWW%6789A=HHS[? % ! HHV, +*Rs LNmaps_as_pydicts)lossystrictcBt|jjd}|j|}|jjd?|j t k(r,|jDcgc]}|jc}S|jScc}w)NTrYrZr)rUr\rr]r rsrtr)rr~r[rxarrs rj to_pylistzArrayExtensionArray.to_pylist4s{+DLL,=,=dKMMM@ 99??1  %)//V*C,5,<,<,>?SCJJL? ?##% %@s2B)Tr) rrrrr`r]rrrrrkrjr6r6s)<*X&':K2L)M&rkr6ceZdZdZdedej ffdZdeejejffdZ e dZ edefdZedefdZedefd Zedej fd Zy ) r=ric||_yr _value_type)rris rjr"z"PandasArrayExtensionDtype.__init__@s %rkrlc\t|tjrP|jj tj |j Dcgc]}|jc}}t|jjd}|j|}t|Scc}wrX) rrS ChunkedArrayr wrap_array concat_arrayschunksr\rUr]PandasArrayExtensionArray)rrlchunkr[rxs rj__from_arrow__z(PandasArrayExtensionDtype.__from_arrow__Cs| eR__ -JJ))"*:*:W\WcWc;deEMM;d*efE+EMM,>,>tLNN.NA (33 / ; rkNcV|tjtk(retjt |j t}t t |j D]}|j |||<|S| |j S|j j|S)a Convert to NumPy Array. Note that Pandas expects a 1D array when dtype is set to object. But for other dtypes, the returned shape is the same as the one of ``data``. More info about pandas 1D requirement for PandasExtensionArray here: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.api.extensions.ExtensionArray.html#pandas.api.extensions.ExtensionArray rd)rrsrtrsrqrrrj)rrsoutr_s rjrz#PandasArrayExtensionArray.__array__ds BHHV$ $((3tzz?&9C3tzz?+ 'AA 'J =:: ::$$U+ +rkdeepr)c0t|jdS)NTr)rr)rrs rjrzPandasArrayExtensionArray.copyxs($??rkrsctdkDr;tfdDr'tj||n |j|}n)tj tt }|dd|||S)Nrc3K|]Z}t|tjxr:|jdjk(xr|jdjk(\ywrN)rrrr rs).0rscalarss rj z;PandasArrayExtensionArray._from_sequence..sW$ jkJq"** % e!''WQZ5E5E*E e!''U\]^U_UeUeJe e$ sA A#)rsrrdr)rqallrrlrirsrt)r+rrsrrs ` rj_from_sequencez(PandasArrayExtensionArray._from_sequence{sp wPandasArrayExtensionArray._concat_same_type..s\&  HHNNil0066 6 e288>>YWX\M_M_MeMe;e e& sA,A/rdFr)rqrrvstackrrsrt)r+rrrs ` rj_concat_same_typez+PandasArrayExtensionArray._concat_same_types y>A #& & # 99;2bhh;= -1 for `allow_fill` is TruerzAInvalid take for empty PandasArrayExtensionArray, must be all -1.Frrb)rrrrsna_valuerirrZrqr IndexErrorrlrrtakerf)rrrrmaskrtooks rjrzPandasArrayExtensionArray.takes !jj< '1'9 ##rzz*\`\f\f\q\q?r b=D" !!# !ijjTQVVD\ !deexx s7| ;4::CXCXY0EBBzzwQ/ $((*$t 4DJ(E::rkc,t|jSr)rqrrs rj__len__z!PandasArrayExtensionArray.__len__s4::rkct|tstdt||j|jk(j S)NzInvalid type to compare to: )rrrrrr)rothers rj__eq__z PandasArrayExtensionArray.__eq__s@%!:;%(DT%[M&RS S ekk)..00rkFr)NF)FN)rrrrrr,r"rrr?rr=r Sequence_rrrsrrrrslicer rr`rrrrrkrjrr_s>> from datasets import Features, ClassLabel >>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])}) >>> features {'label': ClassLabel(names=['bad', 'ok', 'good'])} ``` N num_classesnames names_fileFrrr0rsr_str2int_int2strrrc||_||_|j|j td|jv|j!|j |j|_n|j2t |jDcgc] }t |c}|_nFtdt|jts!tdt|j|jt|j|_nQ|jt|jk7r/tdt|jd|jd|jDcgc] }t |c}|_ t|jDcic]\}}|| c}}|_t|jt|jk7r tdycc}wcc}wcc}}w)Nz7Please provide either names or names_file but not both.z7Please provide either num_classes, names or names_file.z#Please provide names as a list, is zEClassLabel number of names do not match the defined num_classes. Got z names VS z num_classeszBSome label names are duplicated. Each label name should be unique.)rrrrZ_load_names_from_filerrUr SequenceABC TypeErrorrrqrror)rrrr_rs rjrzClassLabel.__post_init__s&$ ?? &4::+AVW W :: *!77H !!-.3D4D4D.EFc!fF  !Z[[DJJ 4A$tzzBRASTU U    #"4::D    TZZ 04::'z$2B2B1C<Q  04zz:tT: 09$--0HIWQqI t}} T]]!3 3ab b 4!G;IsG45G9' G>c|jSrrrs rjrzClassLabel.__call__rrkvaluesr)ct|tst|tstd|dd}t|tr|g}d}|Dcgc]}|j |}}|r|S|dScc}w)a$Conversion class name `string` => `integer`. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].str2int('neg') 0 ``` Values zS should be a string or an Iterable (list, numpy array, pytorch, tensorflow tensors)TFr)rrUrrZ _strval2int)rr return_listrrs rjstr2intzClassLabel.str2ints&#&z&(/K&!tu  fc "XFK7=>e$""5)>>$v3&)3?s A.rc8d}t|}|jj|}|N|jj|j}|# t |}|dks||j k\rd} |rt d||S#t $rd}YwxYw)NFroTzInvalid string class label )rUrgetstriprrrZ)rr failed_parse int_values rjrzClassLabel._strval2int/s E MM%%e,   ))%++-8I , #E I!2~d6F6F)F'+ :5'BC C"(#'L(s B BBcNt|tst|tstd|dd}t|tr|g}d}|D](}d|cxkr|jkrntd|d|Dcgc]}|j t|}}|r|S|dScc}w)a~Conversion `integer` => class name `string`. Regarding unknown/missing labels: passing negative integers raises `ValueError`. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].int2str(0) 'neg' ``` rzU should be an integer or an Iterable (list, numpy array, pytorch, tensorflow tensors)TFrzInvalid integer class label r;)rrrrZrr)rrrrrs rjint2strzClassLabel.int2strDs&#&z&(/K&!vw  fc "XFK GA,D,,, #?!u!EFF G288A$--A'88$v3&)39s8B"c|j tdt|tr|j |}d|cxkr|jksntd|dd|j|S)NzlTrying to use ClassLabel feature with undefined number of class. Please set ClassLabel.names or num_classes.ro Class label r;% greater than configured num_classes )rrZrrUr)r example_datas rjrzClassLabel.encode_examplebsy    #>  lC (<< 5L\4D$4$44|L+;;`aeaqaq`rst trkr\ct|tjrft|dkDrXt j |j }|d|d|jk\r|td|dd|jt|tjrDtj|jDcgc]}||j|ndc}}t||jScc}w)aCast an Arrow array to the `ClassLabel` arrow storage type. The Arrow types that can be converted to the `ClassLabel` pyarrow storage type are: - `pa.string()` - `pa.int()` Args: storage (`Union[pa.StringArray, pa.IntegerArray]`): PyArrow array to cast. Returns: `pa.Int64Array`: Array in the `ClassLabel` arrow storage type. rmaxNrr)rrS IntegerArrayrqpcmin_maxrnrrZ StringArrayrlrrrr)rr\rlabels rj cast_storagezClassLabel.cast_storagers gr /CL14Djj)//1Gu~)gen@P@P.P "75>"22WX\XhXhWij 0hhU\UfUfUhiEE,=!!%(4GiG'4<<00js<C5ct|d5}|jjdDcgc]#}|js|j%c}cdddScc}w#1swYyxYw)Nzutf-8)encoding )openreadsplitr)names_filepathfrs rjrz ClassLabel._load_names_from_files[ .7 3 Sq-.VVX^^D-ARTTZZ\DJJLR S SR S Ss""A)A$A$A)$A))A2)'rrrrrrrrrrrrUrrrrsrrSr0rr rrrrrrrrrrrrrr Int64Arrayr staticmethodrrrkrjrrsc<+/K#'.E49)-J &-d7B 7"E8C="%RXXZGXc]')-HhtCH~&-)-HhtCH~&-|%eDE3Dc:4eCM24uS(]7K40*4eCM24uS(]7K4< 1E".."//*I$J1r}}14SSrkrc$eZdZdZdfd ZxZS)ra@ A `Sequence` is a utility that automatically converts internal dictionary feature into a dictionary of lists. This behavior is implemented to have a compatibility layer with the TensorFlow Datasets library but may be un-wanted in some cases. If you don't want this behavior, you can use a [`List`] or a [`LargeList`] instead of the [`Sequence`]. Args: feature ([`FeatureType`]): Child feature data type of each item within the large list. length (optional `int`, default to -1): Length of the list if it is fixed. Defaults to -1 which means an arbitrary length. Returns: [`List`] of the specified feature, except `dict` of sub-features which are converted to `dict` of lists of sub-features for compatibility with TFDS. c |turat|trQtd|j Dr1|j Dcic]\}}|t |fd|i|}}}|St|!t }|Scc}}w)Nc3>K|]}t|t ywr)rList)r subfeatures rjrz#Sequence.__new__..sX :t44Xslength) rrrrrrrsuper__new__)r+featurerkwargsrrrrs rjr zSequence.__new__s~ 8O7D)Xw~~GWXXOV}}_e3U<64;;-qQ Q4j))*!DLL>; ;rk)rrrrr rrrrrrrUrrrrrrkrjrrsS LFCd7B 7!GXc]!vE>E3>pa.struct rzQWhen defining list feature, you should just provide one example of the inner typer)rFeaturesrSstructget_nested_typerrrrqrZr:rr  large_listrr)rrris rjrrs"&(#yy:@ A3S/&+. . A   FD !yy:@ A3S/&+. . A   FT5M * v;! pq q$VAY/ xx ## FI &$V^^4 }}Z(( FD !$V^^4 xx FMM22 8O' B Bs E$Ec Rt|trH|dk(r | td|2|Dcic]&}|t|||j ||dz(c}SdSt|t t fr||yt|dkDr`|j}|D]}t||sn tt||dz|k7}|r|Dcgc]}t|||dzc}St|St|dr||j|SdS|Scc}w#t$rd}YawxYwcc}w)aEncode a nested example. This is used since some features (in particular ClassLabel) have some logic during encoding. To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be encoded. If the first element needs to be encoded, then all the elements of the list will be encoded, otherwise they'll stay the same. rNz*Got None but expected a dictionary insteadrlevelFr)rrrZencode_nested_examplerrrrqr rr,rrr)rrrr sub_schemarchangedos rjrr0sX&$ A:#+IJ JX^ ^RSQ%fQi519M M ^  FY- . ;3x!|#^^ "%J::zR$"#8ZW\_`W`#aeo#opG[^_VW1*auqyQ__9  ) *-0_v$$S)F$F J3 _"$#G$`s+D"DD$ D! D!token_per_repo_idc t|tr3|/t||Dcic]\}\}}|t||c}}}SdSt|tt fr_|d}|yt |dkDr>|D]}t||snt||k7r|Dcgc]}t||c}St |St|ttfrf|y|j}t |dkDr>|D]}t||snt||k7r|Dcgc]}t||c}St |St|dr$t|ddr||j||SdS|Scc}}}wcc}wcc}w)aDecode a nested example. This is used since some features (in particular Audio and Image) have some logic during decoding. To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be decoded. If the first element needs to be decoded, then all the elements of the list will be decoded, otherwise they'll stay the same. Nrdecode_exampledecodeTr")rrrdecode_nested_examplerrrqrrrr rgetattrr$)rrr"rrsub_objrr!s rjr'r'Xs&$\ddjlo[p q q?WqBW:wQ%j': : q  FT5M *AY ;3x!|"%J::zR)Z@JNJMNQ1*a@NN9  FY- . ;J3x!|"%J::zR)Z@JNJMNQ1*a@NN9  ) *wvx/NRURav$$S r=N)r*loggerwarningr)r+r,s rjregister_featurer0sR~%(c.:V:_:_9``depeyeydzz{ | $/N< rkc t|tr|Dcgc] }t|c}Sd|vst|dtr-|j Dcic]\}}|t|c}}St|}|j d}t j|dxstj|d}|,td|dtt j|tk(r&|j d}tt|fi|S|tk(r&|j d}tt|fi|S|tk(r'|j d}tddt|i|St|Dchc]}|j}}|di|j D cic] \}} ||vs || c} }Scc}wcc}}wcc}wcc} }w)aRegenerate the nested feature object from a deserialized dict. We use the '_type' fields to get the dataclass name to load. generate_from_dict is the recursive helper for Features.from_dict, and allows for a convenient constructor syntax to define features from deserialized JSON dictionaries. This function is used in particular when deserializing a :class:`DatasetInfo` that was dumped to a JSON object. This acts as an analogue to :meth:`Features.from_arrow_schema` and handles the recursive field-by-field instantiation, but doesn't require any mapping to/from pyarrow, except for the fact that it takes advantage of the mapping of pyarrow primitive dtypes that :class:`Value` automatically performs. rNzFeature type 'z&' not found. Available feature types: r r)rrgenerate_from_dictrrpopr*rrrZkeysrrrr r) rrrr class_typer r field_namesrrs rjr2r2s#t7:;e"5);;cZG d;ADM:3'..MM s)C GGG E##E40NGIMM%4NJ>%0VW[\j\o\o\qWrVstuuY'')$+G4<<<T'')$&w/7377X'')$C 27 ;CsCC#)*#56a1666K6  K#))+J$!Qk9IAJ KK-<N$7JsG GG1 G>Gc&t|tjr.|Dcic]"}|jt |j $c}St|tj r*tt |j|jSt|tjrtt |jSt|tjrtt |jSt|trCddttt t"g|j$}||j&|jSt|tj(rt+t-|St/d|dcc}w)a generate_from_arrow_type accepts an arrow DataType and returns a datasets FeatureType to be used as the type for a single field. This is the high-level arrow->datasets type conversion and is inverted by get_nested_type(). This operates at the individual *field* level, whereas Features.from_arrow_schema() operates at the full schema level and holds the methods that represent the bijection from Features<->pyarrow.Schema rN)r rsrdzCannot convert z to a Feature type.)rrS StructTypergenerate_from_arrow_typerFixedSizeListTyperri list_sizeListType LargeListTyperrrrrrrr rRrrhrZ)rr array_features rjr:r:s('2==)NUVU 4UZZ@@VV GR11 2,W-?-?@IZIZ[[ GR[[ ),W-?-?@AA GR-- .1'2D2DEFF G2 3tWgwHW 7==8J8JKK GR[[ )3G<==?7)3FGHHWs'Frrctj|}tj|j|}t |j dz D]}t t|jd|j |z dz d}|j|j |z dz }tjtj|dz|ztj}tjj||}|S)z=Build a PyArrow ListArray from a multidimensional NumPy arrayrrN) rrlrSrgrrr r r rer/ ListArray from_arrays)rrrr_ n_offsets step_offsetsrms rjnumpy_to_pyarrow_listarrayrFs ((3-C XXckkm$ /F 388a< ;3 *|t|jDcic]\}}|t||c}}}nt|tr5||jDcic]\}}|t||c}}}nt|t r&|t t|j |}nJt|tr2|tt|j ||j}n||}||S|Scc}}wcc}}w)zVisit a (possibly nested) feature. Args: feature (FeatureType): the feature type to be checked Returns: visited feature (FeatureType) r8) rrr_visitrrr rr)r rSrrrs rjrUrU<s'8$8GMMOLDAqQq$/LMN GT "7==?C41aAva&CD GY '9VGOOT:;< GT "4w5gnnMN7mk7*s*MCs D4D visit_pathc~t|trD|t|jDcic]\}}|t||||gzc}}|}nt|tr;||jDcic]\}}|t||||gzc}}|}nt|t r8|t t|j ||dgz|j|}nEt|tr,|tt|j ||dgz|}n |||}||S|Scc}}wcc}}w)a0Visit a (possibly nested) feature with its path in the Feature object. A path in a nested feature object is the list of keys that need to be sequentially accessed to get to the sub-feature. For example: - ["foo"] corresponds to the column "foo" - ["foo", 0] corresponds to the sub-feature of the lists in "foo" - ["foo", "bar"] corresponds to the sub-feature of the dicts in "foo" with key "bar" Args: feature (`FeatureType`): the feature type to be checked. Returns: `FeatureType`: the visited feature. rr8) rrr_visit_with_pathrrr rr)r rSrVrrrs rjrXrXTs%&'8$8X_XeXeXghPTPQSTQ 0D*s:J KKhikuv GT "w}}_tq!A'4qc1ABB_akl GT "4($ aS@PQZaZhZhikuv GY '9-gootZSTRUEUVWYcd7J'k7*s*i_s D3:D9 ignore_decode_attributec|t|tr td|jDSt|tt frt |dSt|trt |jSt|trt |jSt|dxr|s t|ddSdS)aRCheck if a (possibly nested) feature requires decoding. Args: feature (FeatureType): the feature type to be checked ignore_decode_attribute (:obj:`bool`, default ``False``): Whether to ignore the current value of the `decode` attribute of the decodable feature types. Returns: :obj:`bool` c32K|]}t|ywr)require_decodingrrs rjrz#require_decoding..sA1#A&Arr$r%T) rrrrrrr\rr rrr()r rYs rjr\r\ts'4 A0@AAA GdE] + ++ GY '00 GT "00w 01 4KGGXt , QU rkct|tr td|jDSt|trt |j St|trt |j St|dS)zCheck if a (possibly nested) feature requires storage casting. Args: feature (FeatureType): the feature type to be checked Returns: :obj:`bool` c32K|]}t|ywrrequire_storage_castr]s rjrz'require_storage_cast..Eq'*Er^r rrrrrrbr rrr s rjrbrbse'4 EGNN4DEEE GY '#GOO44 GT "#GOO44w//rkct|tr td|jDSt|trt |j St|trt |j St|dS)zCheck if a (possibly nested) feature requires embedding data into storage. Args: feature (FeatureType): the feature type to be checked Returns: :obj:`bool` c32K|]}t|ywrrar]s rjrz(require_storage_embed..rcr^ embed_storagerdres rjrequire_storage_embedrise'4 EGNN4DEEE GY '#GOO44 GT "#GOO44w00rkc<tfd}d|_|S)z Wrapper to keep the secondary dictionary, which tracks whether keys are decodable, of the :class:`datasets.Features` object in sync with the main dictionary. c|r |d}|dd}n|jd}|g|i|}t|dsJ|jDcic]\}}|t|c}}|_|Scc}}w)Nrrr_column_requires_decoding)r3rrr\rl)r.r rrcolr rSs rjwrapperz+keep_features_dicts_synced..wrappers #AwD8D%zz&1D4)$)&)t8999]a]g]g]i)j\SRY#/?/H*H)j& *ks A._keep_dicts_synced)r _decorator_name_)rSrns` rjkeep_features_dicts_syncedrqs*  4[   4G Nrkc reZdZdZfdZeejZeejZeejZ eejZ eejZ eejZ eejZ dZedZedZedej(ddfdZedd Zd Zdefd Zed eddfd ZdZdefdZdZddedeeee ee!dfffdZ" ddededeeee ee!dfffdZ#ddedeeee ee!dfffdZ$ddZ%ddZ&d ddZ'xZ(S)!raA special dictionary that defines the internal structure of a dataset. Instantiated with a dictionary of type `dict[str, FieldType]`, where keys are the desired column names, and values are the type of that column. `FieldType` can be one of the following: - [`Value`] feature specifies a single data type value, e.g. `int64` or `string`. - [`ClassLabel`] feature specifies a predefined set of classes which can have labels associated to them and will be stored as integers in the dataset. - Python `dict` specifies a composite feature containing a mapping of sub-fields to sub-features. It's possible to have nested fields of nested fields in an arbitrary manner. - [`List`] or [`LargeList`] specifies a composite feature containing a sequence of sub-features, all of the same feature type. - [`Array2D`], [`Array3D`], [`Array4D`] or [`Array5D`] feature for multidimensional arrays. - [`Audio`] feature to store the absolute path to an audio file or a dictionary with the relative path to an audio file ("path" key) and its bytes content ("bytes" key). This feature loads the audio lazily with a decoder. - [`Image`] feature to store the absolute path to an image file, an `np.ndarray` object, a `PIL.Image.Image` object or a dictionary with the relative path to an image file ("path" key) and its bytes content ("bytes" key). This feature extracts the image data. - [`Video`] feature to store the absolute path to a video file, a `torchcodec.decoders.VideoDecoder` object or a dictionary with the relative path to a video file ("path" key) and its bytes content ("bytes" key). This feature loads the video lazily with a decoder. - [`Pdf`] feature to store the absolute path to a PDF file, a `pdfplumber.pdf.PDF` object or a dictionary with the relative path to a PDF file ("path" key) and its bytes content ("bytes" key). This feature loads the PDF lazily with a PDF reader. - [`Translation`] or [`TranslationVariableLanguages`] feature specific to Machine Translation. c|s td|^}}tt||i||j Dcic]\}}|t |c}}|_fd|j D]\}}t|||<ycc}}w)Nz._check_old_lists('4(F71:?@@Nrk)rrrr"rr\rlrU)r.r rrmr  column_namervrs @rjr"zFeatures.__init__sZ[ [ t h&77@Dzz|; /;sGC!'* *; &   %)JJL A K &w @D  A; sBc&tt|ffSr)rrrs rjr1zFeatures.__reduce__s$t*&&rkct|S)z] Features field types. Returns: :obj:`pyarrow.DataType` )rrs rjrz Features.typest$$rkcdd|jii}tj|jj dt j |iS)zV Features schema. Returns: :obj:`pyarrow.Schema` infofeatures huggingface)rrSrr with_metadatar%r&)r hf_metadatas rj arrow_schemazFeatures.arrow_schema sE DLLN;< yy#11=$**[BY2Z[[rk pa_schemar)ct}|jld|jvr^tj|jdj }d|vr*d|dvr#|ddtj |dd}|j }|Dcic]]}|j|j|vr-|j|j|k(r||jnt|j_}}|di|Scc}w)a Construct [`Features`] from Arrow Schema. It also checks the schema metadata for Hugging Face Datasets features. Non-nullable fields are not supported and set to nullable. Also, pa.dictionary is not supported and it uses its underlying type instead. Therefore datasets convert DictionaryArray objects to their actual values. Args: pa_schema (`pyarrow.Schema`): Arrow Schema. Returns: [`Features`] s huggingfacer{r|r) rmetadatar%r*r% from_dictrrrr:r)r+rmetadata_featuresrmetadata_features_schemarrs rjfrom_arrow_schemazFeatures.from_arrow_schemas$%J    )n @R@R.Rzz)"4"4^"D"K"K"MNH!jHV4D&DRXIYZdIeIq$,$6$6x7G 7S$T!#4#A#A #   JJ::!227O7U7UV[V`V`7aej7j"%**--ejj9 :  zSz sA"C?c(t|}|di|S)a Construct [`Features`] from dict. Regenerate the nested feature object from a deserialized dict. We use the `_type` key to infer the dataclass name of the feature `FieldType`. It allows for a convenient constructor syntax to define features from deserialized JSON dictionaries. This function is used in particular when deserializing a [`DatasetInfo`] that was dumped to a JSON object. This acts as an analogue to [`Features.from_arrow_schema`] and handles the recursive field-by-field instantiation, but doesn't require any mapping to/from pyarrow, except for the fact that it takes advantage of the mapping of pyarrow primitive dtypes that [`Value`] automatically performs. Args: dic (`dict[str, Any]`): Python dictionary. Returns: `Features` Example:: >>> Features.from_dict({'_type': {'dtype': 'string', 'id': None, '_type': 'Value'}}) {'_type': Value('string')} r)r2)r+dicrs rjrzFeatures.from_dict:s4!%zSzrkct|Sr)rrs rjrzFeatures.to_dictWs d|rkc|j}dtdtfddtttfdtffd dtdtffd |dS)Nr r)cRt|tstdt|d|dD]|}t|j |trt ||dgk(r ||d||<t|j |ts_t ||dgk(sr||d||<~t|j dtrVt|dj dt r4t |ddDcic]\}}t||c}}|dd<|Scc}}w)NExpected a dict but got a : rrsequencersr class_labelr)rrrrrrrorU)r  list_typelabel_id label_names rjsimplifyz(Features._to_yaml_list..simplify^s5gt,".to_yaml_innersY#t$.K'"wwy1H#\=3J$Rc$RSSf_"wwy1H#V]8-D$L$LMMg%J3#%;E%BCC#X/Ee/Lc.R%STT$gjgpgpgr&sUcUY[c'P h8O'P&sttC&-A2G)H IJJC'$T#Y//"DT#YKrRUQV WXX 'ts7D6c t|tr*|jDcic]\}}||c}}St|tr|Dcgc] }| c}St|trt|S|Scc}}wcc}wr)rrrrr)rrr to_yaml_typess rjrz-Features._to_yaml_list..to_yaml_typessy#t$8; D1=++DDC&256Q a(66C'$T#Y// E6s BB r)rrrr)r yaml_datarrrs @@@rj _to_yaml_listzFeatures._to_yaml_listZskLLN  d t D YuT4Z0 YT Y0 t  ]95h?@@rkrctj|}dtdtfddtttfdtttfffd |j |S)Nr r)c xt|tstdt|d|dD],}t|j |t s#d||i||<.t|j dtrt|dj dtrt |ddt}|r[|Dcgc] }t|c}ttt|dd zk7rtd t|dd zd |Dcgc] }|dd|c}|dd<|Scc}wcc}w) Nrrrrsrr)rrorz1ClassLabel expected a value for all label ids [0:z] but some ids are missing.) rrrrrrUsortedrrrrZ)r r label_idsrs rj unsimplifyz,Features._from_yaml_list..unsimplifysNgt,".from_yaml_innersT#t$IT#YL(.z#/B/B5/IJH%xM3MMMJ&!#e*d3#2:c?3F3Fu3M#N6>^^5E  1k!9k"RS"R'6"RR  $3:c?3F3Fu3M#N )8LsLGVLLF?.z#/B/B5/IJH%xH3HHHH$*3x=99g%!#g,4S!#g,/#AB(f-BBNQRWY\o^ND(oh77^^"DT#YKrRUQV WXX; $ *S$+-CCL-Q#RRSC^s$G4G!H*H!G=<G=)rdeepcopyrrrr)r+rrrs @@rj_from_yaml_listzFeatures._from_yaml_listscMM),    6( YtTz!2( YuT4Z7H( YT}}_Y788rkc0t|}t||S)z Encode example into a format for Arrow. Args: example (`dict[str, Any]`): Data in a Dataset row. Returns: `dict[str, Any]` rr)rexamples rjrzFeatures.encode_examples)1$T733rkrwc`t|}|Dcgc]}t|||dc}Scc}w)a Encode column into a format for Arrow. Args: column (`list[Any]`): Data in a Dataset column. column_name (`str`): Dataset column name. Returns: `list[Any]` rrr)rcolumnrwrs rj encode_columnzFeatures.encode_columns1(/RXY3%d;&7AFYYYs+c i}t|t|k7r#tdt|dt||jD]2\}}t|}|Dcgc]}t |||dc}||<4|Scc}w)z Encode batch into a format for Arrow. Args: batch (`dict[str, list[Any]]`): Data in a Dataset batch. Returns: `dict[str, list[Any]]` zColumn mismatch between batch z and features rr)setrZrrr)rbatch encoded_batchrrrs rj encode_batchzFeatures.encode_batchs u:T "=c%j\X[\`XaWbcd d ;;= dKC+F3F\b!cUX"7S 3a"P!cM#  d"ds"BNrr"c t|jDcic] \}}||vs ||c}}|Dcic](\}\}}||j|rt|||n|*c}}}Scc}}wcc}}}w)aDecode example with custom feature decoding. Args: example (`dict[str, Any]`): Dataset row data. token_per_repo_id (`dict`, *optional*): To access and decode audio or image files from private repositories on the Hub, you can pass a dictionary `repo_id (str) -> token (bool or str)`. Returns: `dict[str, Any]` r&)rrrlr')rrr"rrrwr s rjr$zFeatures.decode_example"s$2:.2jjlM UcWneMw2   . -gu --k:/wQbc   N  s A* A* -A0rct|j|r#|Dcgc]}|t||||ndc}S|Scc}w)zDecode column with custom feature decoding. Args: column (`list[Any]`): Dataset column data. column_name (`str`): Dataset column name. Returns: `list[Any]` Nr&)rlr')rrrwr"rs rj decode_columnzFeatures.decode_column9s_*--k:$  $&d;&7Rcd    s5rc i}|jD]<\}}|j|r#|Dcgc]}|t||||ndc}n|||<>|Scc}w)aDecode batch with custom feature decoding. Args: batch (`dict[str, list[Any]]`): Dataset batch data. token_per_repo_id (`dict`, *optional*): To access and decode audio or image files from private repositories on the Hub, you can pass a dictionary repo_id (str) -> token (bool or str) Returns: `dict[str, list[Any]]` Nr&)rrlr')rrr" decoded_batchrwrrs rj decode_batchzFeatures.decode_batchRs #(;;=  K11+>"( (*${*;UVgh + & sAc,tj|S)a Make a deep copy of [`Features`]. Returns: [`Features`] Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> copy_of_features = ds.features.copy() >>> copy_of_features {'label': ClassLabel(names=['neg', 'pos']), 'text': Value('string')} ``` )rrrs rjrz Features.copyms$}}T""rkc4dfd t||S)ai Reorder Features fields to match the field order of other [`Features`]. The order of the fields is important since it matters for the underlying arrow data. Re-ordering the fields allows to make the underlying arrow data type match. Args: other ([`Features`]): The other [`Features`] to align with. Returns: [`Features`] Example:: >>> from datasets import Features, List, Value >>> # let's say we have two features with a different order of nested fields (for a and b for example) >>> f1 = Features({"root": {"a": Value("string"), "b": Value("string")}}) >>> f2 = Features({"root": {"b": Value("string"), "a": Value("string")}}) >>> assert f1.type != f2.type >>> # re-ordering keeps the base structure (here List is defined at the root level), but makes the fields order match >>> f1.reorder_fields_as(f2) {'root': List({'b': Value('string'), 'a': Value('string')})} >>> assert f1.reorder_fields_as(f2).type == f2.type c P|rd|ddznd}t|trt|tstd|d||zt|t|k7r[d|d|d|j |j z d |j |j z d |z}t||Dcic]}||||||d |zc}St|t rZt|t std|d||zt |j |j |d z|j St|trNt|tstd|d||zt|j |j |d zS|Scc}w)Nz at rzType mismatch: between rpzKeys mismatch: between z (source) and z (target). z are missing from target and z are missing from sourcer9z.r8) rrrZrr4rr rr)sourcetargetstackstack_positionmessagerrecursive_reorders rjrz5Features.reorder_fields_as..recursive_reorders38VeABi/bN&$'!&$/$'>vheF8%TWe%eff&>VF^31&x|!;;=6;;=89:%{{}v{{}<==UWYgh %W--gmn`c.vc{F3KSTUXTYQZIZ[[nnFD)!&$/$'>vheF8%TWe%eff-fnnfnneV_N_`ioivivwwFI.!&)4$'>vheF8%TWe%eff !26>>6>>SX[dSd!eff os8F#)r)r)rrrs @rjreorder_fields_aszFeatures.reorder_fields_ass6 0)$677rkc td|D]}d}|j}|jD]\}}t|tr>d}|j |jDcic] \}}|d||c}}||=Tt |dsa|j|k7sud}|j |jjDcic] \}}|d||c}}||=|}|s|S|Scc}}wcc}}w)aFlatten the features. Every dictionary column is removed and is replaced by all the subfields it contains. The new fields are named by concatenating the name of the original column and the subfield name like this: `.`. If a column contains nested dictionaries, then all the lower-level subfields names are also concatenated to form new columns: `..`, etc. Returns: [`Features`]: The flattened features. Example: ```py >>> from datasets import load_dataset >>> ds = load_dataset("rajpurkar/squad", split="train") >>> ds.features.flatten() {'answers.answer_start': List(Value('int32'), id=None), 'answers.text': List(Value('string'), id=None), 'context': Value('string'), 'id': Value('string'), 'question': Value('string'), 'title': Value('string')} ``` rTFr9rg)rrrrrupdaterrg) r max_depthdepth no_change flattenedrwrrrs rjrgzFeatures.flattens41i( EI I+/::< /' Zj$/ %I$$*JZJZJ\%]$!Q Qqc&:A&=%]^!+.Z3 8J8J8LPZ8Z %I$$*J\J\J^JdJdJf%g$!Q Qqc&:A&=%gh!+. /D   &^&hs (C?D)r)rr)rrr)r)))rrrrr"rqrr __delitem__r setdefaultr3popitemclearr1rrrr?rSSchemarrrrrrrrUrrrrr,r$rrrrrgr r s@rjrrs:A(-T-=-=>K,T-=-=>K ' 4F+DOO._fix_old_list s& gt $=gajIJ Jrk)rU)r rs rjrr s '= ))rk)FTrr)r)rrr%rrcollections.abcrrrrr dataclassesrrrr functoolsr r operatorr typingr rrrrrrrpandasrrCrSpyarrow.computecomputer pyarrow.typespandas.api.extensionsrPandasExtensionArrayrPandasExtensionDtyperrnamingrrtablerutilsrrutils.py_utilsrrraudior imager!r"rr#r$ translationr%r&videor' get_loggerrr.rRrUrhrr,rrrrr rrrrr rrArErHrKregister_extension_typerUr6r=rrrrrrr FeatureTyperrrr'r*rrr0r2r:rrBrFrrJrLrNrPrRrU _VisitPathrXr\rbrirqrrrrrrkrjrs b -3199#DDHHC)CC*+B   H %A`A`A`HRCRBKKRjwwwVZw_dehjnen_owt  ]` 2 P8P8P8f   BhB B0 BhB B0 BhB B0 BhB B0+:B,,+:\0000 /@A/ 7CD/ gFG/IJr rTrdr,:&"++:&z 4 De1 4e1P;  BSBS BSJB <8<<6 888(           !  *Xk5JVZ,KBKKB%P*(4USVX\^bSbMcHcCd:e*\ NNE+ ))+G  MM4 g g g g NNE NNE NNELL#*S+%&$ / / / /#LC#LLIbkkIkI6 BJJ bkk R\\  5$x7I2J 5r|| 5'bjj1A''`b`l`l'" wE"**d2B,C w2;; wbdbnbn w 5s 5-B 5rxx 5 +K+x x ?T0T'U+Ze+*%WQZ( ) vx+ + (+z)BH[DY)Y Z+hr++@ k D UY 00+0$0$1;141$,YtYx c4> cd8n cT(^,*3*;*rk