U Cv f@sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!ddl"Z#ddl$Z%erddl&m'Z'm(Z(m)Z)edZ*edZ+ed Z,d d d d d d Z-dd d dddddZ.dd ddddZ/ddddZ0ddZ1ddZ2d d d d!d"d#Z3d$d%Z4d&d'd(d)d*Z5e3fd+d+d,dd-d.d/Z6e3fd0d+d,dd-d1d2Z7d3d4d5d6d7Z8d3d d5d8d9Z9d3d:d5d;d<Z:d3d d5d=d>Z;d?d@d dAdBdCdDZdGkr*ddHlm?Z?n ddHl@m?Z?Wn4eAk rlerTndd3d d dJdKdLZBYnXdd3d dMdJdNdLZBd3d dOdPdQZCd3dRd5dSdTZDd3dRd5dUdVZEe3fd+d+d,d dWdXdYZFe3fd+d+d,d0d-dZd[ZGe3fd+d+d,d0d-d\d]ZHGd^d_d_ee*e+fZId_d`dadbZJGdcddddee*e+fZKGdedfdfee,ZLGdgdhdhZMGdidjdjeMZNGdkdldlZOejPdmdnZQd d dodpdqZRddsd`dtduZSddvd`dwdxZTddvd`dydzZUd d`d{d|ZVd3dMd}d~dZWd3dd}ddZXd3dd}ddZYd+ddddZZddZ[Gdddee*e+fZ\ddddddddZ]ddddddZ^dddddddZ_dddddddZ`edddZae!dIdIdddd dddddZbe!dIdddd dddddZbdIdIdddd d ddddZbe!dIdIdddd dddddZce!dIdddd dddddZcdIdIdddd d ddddZcddddddZdedZeGdddeeeZfGddÄdeZgegjhZiddńZjd d`ddDŽZkd d dȜddʄZlddd`dd̈́ZmdddτZndS)z(Internal utilities; not for external use) annotationsN)Enum) TYPE_CHECKINGAnyCallable Collection ContainerGenericHashableIterableIteratorLiteralMappingMutableMapping MutableSetSequenceTypeVarcastoverload)DimsErrorOptionsWithWarn OrderedDimsKVTstr)old_namenew_namereturncCs|d|dS)Nz has been deprecated. Use z instead.)rrrr5/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/utils.py alias_messageQsr!intNone)rr stacklevelrcCstjt||t|ddS)N)r%)warningswarnr! FutureWarning)rrr%rrr alias_warningUs r)zCallable[..., T])objrrcs8ttsttfdd}tj|_|S)Ncstj||SN)r)__name__argskwargsr*rrr wrapper^s zalias..wrapper) isinstancerAssertionError functoolswrapsr!r,__doc__)r*rr1rr0r alias[s r7znp.ndarray | pd.IndexarraycCsLt|tjrtd}n0t|dr,|jj}nt|jsBtd}n|j}|S)zReturn a numpy compatible dtype from either a numpy array or a pandas.Index. Used for wrapping a pandas.Index as an xarray,Variable. O categories)r2pdZ PeriodIndexnpdtypehasattrr;is_valid_numpy_dtyper9r>rrr get_valid_numpy_dtypegs      rBcCsNddlm}z|j|}Wntk r.YnX|jdkrJtj||jd}|S)zmaybe coerce a pandas Index back to a nunpy array of type str pd.Index uses object-dtype to store str - try to avoid this for coords r)dtypesZSUr>) xarray.corerC result_type TypeErrorkindr=Zasarraytype)indexZoriginal_coordsrCrFrrr maybe_coerce_to_str{s  rKcCs*t|tjr"|j|jkr"||S|SdS)zWrap a transformed array with __array_wrap__ if it can be done safely. This lets us treat arbitrary functions that take and return ndarray objects like ufuncs, as long as they return an array with the same shape. N)r2r=ndarrayshapeZ__array_wrap__)originalZ new_arrayrrr maybe_wrap_arrays rObool)firstsecondrcCsvddlm}||krdSt|tjs0t|tjr<|||St|tsPt|trZt||S||kptt |ott |S)zCompare two objects for equivalence (identity or equality), using array_equiv if either object is an ndarray. If both objects are lists, equivalent is sequentially called on all the elements. r)duck_array_opsT) rErSr2r=rLZ array_equivlist list_equivr<Zisnull)rQrRrSrrr equivalents   rVcCs>d}t|t|krdSt||D]\}}|o6t||}q"|S)NTF)lenziprV)rQrRequivfsrrr rUs rU Iterable[T]ztuple[T, Iterator[T]])iterablercCs"t|}t|}|t|g|fS)zxReturns the first value from iterable, as well as a new iterator with the same content as the original iterable )iternext itertoolschain)r]genpeekrrr peek_atsrd Mapping[K, V]zCallable[[V, V], bool]) first_dict second_dictcompatrcCs:|D],\}}||kr||||std|qdS)aHCheck the safety of updating one dictionary with another. Raises ValueError if dictionaries have non-compatible values for any key, where compatibility is determined by identity (they are the same item) or the `compat` function. Parameters ---------- first_dict, second_dict : dict-like All items in the second dictionary are checked against for conflicts against items in the first dictionary. compat : function, optional Binary operator to determine if two values are compatible. By default, checks for equivalence. zHunsafe to merge dictionaries without overriding values; conflicting key N)items ValueError)rfrgrhkvrrr update_safety_checks rmMutableMapping[K, V]cCs2t|D]$}||ks&|||||s||=qdS)aRemove incompatible items from the first dictionary in-place. Items are retained if their keys are found in both dictionaries and the values are compatible. Parameters ---------- first_dict, second_dict : dict-like Mappings to merge. compat : function, optional Binary operator to determine if two values are compatible. By default, checks for equivalence. N)rT)rfrgrhrkrrr remove_incompatible_itemss rorzTypeGuard[Mapping]valuercCst|dot|dS)Nkeys __getitem__)r?rqrrr is_dict_likesrucCst|to|tdkSr+)r2slicertrrr is_full_slicesrwzTypeGuard[list | tuple]cCst|ttfSr+)r2rTtuplertrrr is_list_likesrycCsLt|tjrdSt|doJt|doJt|doJt|drBt|dpJt|dS)NTndimrMr>__array_function__Z__array_ufunc____array_namespace__)r2r=rLr?rtrrr is_duck_arrays  r}zMapping[Any, T] | NonezMapping[str, T]zMapping[Hashable, T]) pos_kwargs kw_kwargs func_namercCsP|dks|ikr"ttttf|St|s:td|d|rLtd||S)Nzthe first argument to .z must be a dictionaryz9cannot specify both keyword and positional arguments to .)rrr rrurj)r~rrrrr either_dict_or_kwargs srcCsXddlm}|r t|dddk}|pVt|ttfpVt|tf|pTt|dpTt|d S)Nr)NON_NUMPY_SUPPORTED_ARRAY_TYPESrzr{r|)Zxarray.core.variablergetattrr2rbytesr r?)rq include_0drrrr _is_scalars  r)r" ) TypeGuardT)rqrrcCs t||S)zfWhether to treat a value as a scalar. Any non-iterable, string, or 0-D array rrqrrrr is_scalar<srzTypeGuard[Hashable]cCs t||S)z^Whether to treat a value as a scalar. Any non-iterable, string, or 0-D array rrrrr rEs)r>rc Cs2zt|Wnttfk r(YdSXdSdS)NFT)r=r>rGrjrDrrr r@Ms r@z np.ndarraycCstjdtd}||d<|S)z@Given a value, wrap it in a 0-D numpy.ndarray with dtype=object.rrD)r=emptyobject)rqresultrrr to_0d_object_arrayVsrcCs6t|s t|tjr*|jdkr*t|St|SdS)z.Given a value, wrap it in a 0-D numpy.ndarray.rN)r=Zisscalarr2rLrzr9rrtrrr to_0d_array]s  r)rQrRrhrcs@D]$}||ks"||||sdSqtfdd|DS)aTest equivalence of two dict-like objects. If any of the values are numpy arrays, compare them correctly. Parameters ---------- first, second : dict-like Dictionaries to compare for equality compat : function, optional Binary operator to determine if two values are compatible. By default, checks for equivalence. Returns ------- equals : bool True if the dictionaries are equal Fc3s|]}|kVqdSr+r).0rkrQrr }szdict_equiv..)all)rQrRrhrkrrr dict_equivesrcCst|}t||||S)aReturn the intersection of two dictionaries as a new dictionary. Items are retained if their keys are found in both dictionaries and the values are compatible. Parameters ---------- first_dict, second_dict : dict-like Mappings to merge. compat : function, optional Binary operator to determine if two values are compatible. By default, checks for equivalence. Returns ------- intersection : dict Intersection of the contents. )dictrorfrgrhZnew_dictrrr compat_dict_intersections rcCs"t|}t||||||S)aReturn the union of two dictionaries as a new dictionary. An exception is raised if any keys are found in both dictionaries and the values are not compatible. Parameters ---------- first_dict, second_dict : dict-like Mappings to merge. compat : function, optional Binary operator to determine if two values are compatible. By default, checks for equivalence. Returns ------- union : dict union of the contents. )rrmupdaterrrr compat_dict_unions  rc@sleZdZdZdZddddZdddd d Zd d d dZdd ddZdddddZ dd ddZ dS)FrozenzWrapper around an object implementing the mapping interface to make it immutable. If you really want to modify the mapping, the mutable version is saved under the `mapping` attribute. mappingrecCs ||_dSr+r)selfrrrr __init__szFrozen.__init__rrkeyrcCs |j|Sr+rrrrrr rsszFrozen.__getitem__ Iterator[K]rcCs t|jSr+)r^rrrrr __iter__szFrozen.__iter__r#cCs t|jSr+)rWrrrrr __len__szFrozen.__len__rrPcCs ||jkSr+rrrrr __contains__szFrozen.__contains__rcCst|jd|jdSN())rIr,rrrrr __repr__szFrozen.__repr__N) r, __module__ __qualname__r6 __slots__rrsrrrrrrrr rsrrcOstt||Sr+)rrr-rrr FrozenDictsrc@sPeZdZdZdZdddddZdd d d d Zd dddZddddZdS)HybridMappingProxyaImplements the Mapping interface. Uses the wrapped mapping for item lookup and a separate wrapped keys collection for iteration. Can be used to construct a mapping object from another dict-like object without eagerly accessing its items or when a mapping object is expected but only iteration over keys is actually used. Note: HybridMappingProxy does not validate consistency of the provided `keys` and `mapping`. It is the caller's responsibility to ensure that they are suitable for the task at hand. _keysrz Collection[K]re)rrrcCs||_||_dSr+r)rrrrrrr rszHybridMappingProxy.__init__rrrcCs |j|Sr+rrrrr rsszHybridMappingProxy.__getitem__rrcCs t|jSr+)r^rrrrr rszHybridMappingProxy.__iter__r#cCs t|jSr+)rWrrrrr rszHybridMappingProxy.__len__N) r,rrr6rrrsrrrrrr rs  rc@seZdZUdZded<dZd#dddd Zd d d d dZddddZddddZ ddd ddZ ddd ddZ dddddZ d dd!d"Z dS)$ OrderedSetzA simple ordered set. The API matches the builtin set, but it preserves insertion order of elements, like a dict. Note that, unlike in an OrderedDict, equality tests are not order-sensitive. z dict[T, None]_drNzIterable[T] | None)valuescCsi|_|dk r||dSr+)rr)rrrrr rszOrderedSet.__init__r rPrpcCs ||jkSr+rrrqrrr rszOrderedSet.__contains__z Iterator[T]rcCs t|jSr+)r^rrrrr r szOrderedSet.__iter__r#cCs t|jSr+)rWrrrrr r szOrderedSet.__len__rr$cCsd|j|<dSr+rrrrr addszOrderedSet.addcCs |j|=dSr+rrrrr discardszOrderedSet.discardr\)rrcCs|D]}d|j|<qdSr+r)rrrlrrr rszOrderedSet.updatercCst|jdt|dSr)rIr,rTrrrr rszOrderedSet.__repr__)N)r,rrr6__annotations__rrrrrrrrrrrrr rs rc@sLeZdZdZdZedddddZeddddd Zdddd d Zd S) NdimSizeLenMixinzMixin class that extends a class that defines a ``shape`` property to one that also defines ``ndim``, ``size`` and ``__len__``. rrr#rrcCs t|jS)zk Number of array dimensions. See Also -------- numpy.ndarray.ndim )rWrMrrrr rz's zNdimSizeLenMixin.ndimcCs t|jS)u Number of elements in the array. Equal to ``np.prod(a.shape)``, i.e., the product of the array’s dimensions. See Also -------- numpy.ndarray.size )mathprodrMrrrr size2s zNdimSizeLenMixin.sizecCs.z |jdWStk r(tdYnXdS)Nrzlen() of unsized object)rM IndexErrorrGrrrr r?s zNdimSizeLenMixin.__len__N) r,rrr6rpropertyrzrrrrrr r s  rc@sZeZdZdZdZedddddZedddd d Zdd d d ZdddddZ dS) NDArrayMixinaMixin class for making wrappers of N-dimensional arrays that conform to the ndarray interface required for the data argument to Variable objects. A subclass should set the `array` property and override one or more of `dtype`, `shape` and `__getitem__`. rrznp.dtypercCs|jjSr+rArrrr r>PszNDArrayMixin.dtypeztuple[int, ...]cCs|jjSr+)r9rMrrrr rMTszNDArrayMixin.shapercCs |j|Sr+r8rrrr rsXszNDArrayMixin.__getitem__rcCst|jd|jdS)Nz(array=r)rIr,r9rrrr r[szNDArrayMixin.__repr__N) r,rrr6rrr>rMrsrrrrr rFsrc@sTeZdZdZdZddddZdddd Zd dd d Zd dddZddZ dS) ReprObjectzDObject that prints as the given value, for use with sentinel values._valuerrtcCs ||_dSr+rrrrr rdszReprObject.__init__rcCs|jSr+rrrrr rgszReprObject.__repr__rPcCst|tr|j|jkSdS)NF)r2rr)rotherrrr __eq__js  zReprObject.__eq__r#cCstt||jfSr+)hashrIrrrrr __hash__oszReprObject.__hash__cCsddlm}|t||jfS)Nr)normalize_token)Z dask.baserrIr)rrrrr __dask_tokenize__rs zReprObject.__dask_tokenize__N) r,rrr6rrrrrrrrrr r_srccs.z dVWntk r(|YnXdS)zContext manager to ensure that a file opened by xarray is closed if an exception is raised before the user sees the file object. N) Exceptionclose)rZrrr close_on_errorxs  r)pathrcCsttd|S)zFinds URLs of the form protocol:// or protocol:: This also matches for http[s]://, which were the only remote URLs supported in <=v0.16.2. z^[a-z][a-z0-9]*(\://|\:\:))rPresearch)rrrr is_remote_urisrrcCsft|tr|d|}nJt|tjrP|dkr:|d||}|dntdt||S)Nrz"cannot read the magic number from ) r2rioIOBasetellseekreadrGrIZfilename_or_objcountZ magic_numberrrr read_magic_number_from_files      rz bytes | Nonec Csjt|tst|drft|}z.t|d}t||W5QRWSQRXWnttfk rdYnXdS)N __fspath__rb) r2rr?osfspathopenrFileNotFoundErrorrG)ZpathlikerrrZrrr try_read_magic_number_from_paths  "rcCs:t||}|dkr6zt||}Wntk r4YnX|Sr+)rrrGrrrr 'try_read_magic_number_from_file_or_paths rcKs4tj|td}t|}ttj||f|S)zReturn True if values of an array are uniformly spaced and sorted. >>> is_uniform_spaced(range(5)) True >>> is_uniform_spaced([-4, 0, 100]) False kwargs are additional arguments to ``np.isclose`` rD)r=r9floatZdiffrPiscloseminmax)Zarrr/Zdiffsrrr is_uniform_spaceds  r)rlrcCs(z t|Wntk r"YdSXdS)z$Determine whether `v` can be hashed.FT)rrGrlrrr hashables  rzTypeGuard[Iterable[Any]]cCs(z t|Wntk r"YdSXdS)z"Determine whether `v` is iterable.FT)r^rGrrrr r]s  r]zTypeGuard[Iterable[Hashable]]cCs6z t|}Wntk r"YdSXtdd|DS)z2Determine whether `v` is an Iterable of Hashables.Fcss|]}t|VqdSr+)r)relmrrr rsz'iterable_of_hashable..)r^rGr)rlitrrr iterable_of_hashables  rz dict[K, V])attrsrcCsPt|}|D]:\}}t|tjr2|||<qt|tjr|||<q|S)zaConvert attribute values from numpy objects to native Python objects, for use in to_dict )rrir2r=rLtolistZgenericitem)rrkrlrrr decode_numpy_dict_valuess  rcCs:t|jtjr|d}nt|jtjr6|d}|S)zZConvert val out of numpy time, for use in to_dict. Needed because of numpy bug GH#7619zdatetime64[us]ztimedelta64[us])r=Z issubdtyper>Z datetime64ZastypeZ timedelta64)valrrr ensure_us_time_resolutions   rc@seZdZdZdZdddddZdd d d d Zdd d dddZdd d ddZdd d ddZ ddddZ ddddZ dS) HiddenKeyDictz6Acts like a normal dictionary, but hides certain keys._data _hidden_keysrnz Iterable[K])data hidden_keyscCs||_t||_dSr+)r frozensetr)rrrrrr rszHiddenKeyDict.__init__rr$rcCs||jkrtd|ddS)NzKey `z ` is hidden.)rKeyErrorrrrr _raise_if_hiddens zHiddenKeyDict._raise_if_hiddenr)rrqrcCs||||j|<dSr+rr)rrrqrrr __setitem__s zHiddenKeyDict.__setitem__cCs|||j|Sr+rrrrr rss zHiddenKeyDict.__getitem__cCs|||j|=dSr+rrrrr __delitem__ s zHiddenKeyDict.__delitem__rrccs |jD]}||jkr|VqdSr+r)rrkrrr r s  zHiddenKeyDict.__iter__r#cCs"t|j|j@}t|j|Sr+)rWrrrr)rZ num_hiddenrrr rszHiddenKeyDict.__len__N) r,rrr6rrrrrsrrrrrrr rsrraiserrr ) dims_supplieddims_all missing_dimsrc#sdkrtt|t|kr$tdtddkr>tdfdd|D}t||}|D]}|dkrx|EdHq`|Vq`n:t||}t|t|Artd|d |EdHdS) z Resolves a supplied list containing an ellipsis representing other items, to a generator with the 'realized' list of all items .&Cannot use ellipsis with repeated dimsMore than one ellipsis suppliedcsg|]}|kr|qSrrrdrrr %szinfix_dims..Nz must be a permuted list of z, unless `...` is included)rWsetrjrTrdrop_missing_dims)rrr other_dimsZ existing_dimsr rr r infix_dimss"     rzContainer[Hashable]r )dimsnew_dimrcCs||krdt|}q|S)a^Get an new dimension name based on new_dim, that is not used in dims. If the same name exists, we add an underscore(s) in the head. Example1: dims: ['a', 'b', 'c'] new_dim: ['_rolling'] -> ['_rolling'] Example2: dims: ['a', 'b', 'c', '_rolling'] new_dim: ['_rolling'] -> ['__rolling'] _)r)rrrrr get_temp_dimname5s rzMapping[Any, Any]z&Iterable[Hashable] | Mapping[Any, int]zMapping[Hashable, Any])indexersrrrcs|dkr4|t}|r0td|d|S|dkrt|}|t}|rntd|d|D]}||qr|S|dkrfdd|DStd|d d S) zDepending on the setting of missing_dims, drop any dimensions from indexers that are not present in dims. Parameters ---------- indexers : dict dims : sequence missing_dims : {"raise", "warn", "ignore"} r Dimensions ' do not exist. Expected one or more of r'ignorecsi|]\}}|kr||qSrr)rrrrrr osz+drop_dims_from_indexers..Unrecognised option  for missing_dims argumentN)rrr rjrr&r'popri)rrrinvalidrrrr drop_dims_from_indexersGs,  rzIterable[Hashable]) supplied_dimsrrrcs|dkr>dd|D}|t}|r:td|d|S|dkrt|t}|rptd|dfdd|DS|d krfd d|DStd |d d S)aDepending on the setting of missing_dims, drop any dimensions from supplied_dims that are not present in dims. Parameters ---------- supplied_dims : Iterable of Hashable dims : Iterable of Hashable missing_dims : {"raise", "warn", "ignore"} rcSsh|]}|dk r|qS.rrrrrr sz$drop_missing_dims..rrr'cs g|]}|ks|dkr|qSr rr!rrr r sz%drop_missing_dims..rcs g|]}|ks|dkr|qSr rr!rrr r srrN)r rjr&r')rrrZsupplied_dims_setrrrr r ws(  r T_NoneZellipsis) check_exists replace_nonez!str | Iterable[Hashable] | T_Noneztuple[Hashable, ...]z Literal[True])dimall_dimsr$r%rcCsdSr+rr&r'r$r%rrr parse_dimssr))r$zLiteral[False]ztuple[Hashable, ...] | T_NonecCsdSr+rr(rrr r)srz&tuple[Hashable, ...] | None | ellipsiscCsJ|dks|dkr|r|S|St|tr,|f}|rBtt|t|t|S)aParse one or more dimensions. A single dimension must be always a str, multiple dimensions can be Hashables. This supports e.g. using a tuple as a dimension. If you supply e.g. a set of dimensions the order cannot be conserved, but for sequences it will be. Parameters ---------- dim : str, Iterable of Hashable, "..." or None Dimension(s) to parse. all_dims : tuple of Hashable All possible dimensions. check_exists: bool, default: True if True, check if dim is a subset of all_dims. replace_none : bool, default: True If True, return all_dims if dim is None or "...". Returns ------- parsed_dims : tuple of Hashable Input dimensions as a tuple. N.)r2r _check_dimsr rxr(rrr r)s z,str | Sequence[Hashable | ellipsis] | T_NonecCsdSr+rr(rrr parse_ordered_dimssr+cCsdSr+rr(rrr r+srcs|dk r|dk rt|tsd|krt|t|}|r@t|t|t|krXtdt|}|ddkrvtdtfdd|D}|d}|d||||ddSt ||||dSdS) aParse one or more dimensions. A single dimension must be always a str, multiple dimensions can be Hashables. This supports e.g. using a tuple as a dimension. An ellipsis ("...") in a sequence of dimensions will be replaced with all remaining dimensions. This only makes sense when the input is a sequence and not e.g. a set. Parameters ---------- dim : str, Sequence of Hashable or "...", "..." or None Dimension(s) to parse. If "..." appears in a Sequence it always gets replaced with all remaining dims all_dims : tuple of Hashable All possible dimensions. check_exists: bool, default: True if True, check if dim is a subset of all_dims. replace_none : bool, default: True If True, return all_dims if dim is None. Returns ------- parsed_dims : tuple of Hashable Input dimensions as a tuple. N.rrrc3s|]}|kr|VqdSr+rrZdims_setrr r%sz%parse_ordered_dims..r() r2rr r*rWrjrxrrJr))r&r'r$r%Z all_dims_setrridxrr,r r+s& "   zset[Hashable | ellipsis]z set[Hashable])r&r'rcCsB||}|r>|dhkr>ddd|D}td|d|dS)N.z, css|]}d|dVqdS)'Nrrrrr r5sz_check_dims..z Dimension(s) r)joinrj)r&r'Z wrong_dimsZwrong_dims_strrrr r*2s r* _Accessorc@sXeZdZdZdddddZeddddd Zed d dd d Zd dddd ZdS)UncachedAccessorzActs like a property, but on both classes and class instances This class is necessary because some tools (e.g. pydoc and sphinx) inspect classes for which property returns itself and not the accessor. ztype[_Accessor]r$)accessorrcCs ||_dSr+ _accessor)rr2rrr rFszUncachedAccessor.__init__)r*rcCsdSr+rrr*clsrrr __get__IszUncachedAccessor.__get__rr0cCsdSr+rr5rrr r7Msz None | objectztype[_Accessor] | _AccessorcCs|dkr|jS||Sr+r3r5rrr r7QsN)r,rrr6rrr7rrrr r1>sr1c@seZdZdZdS)DefaultrN)r,rrtokenrrrr r8Ysr8ccs.|D]$}t|tr"t|EdHq|VqdSr+)r2rTiterate_nested)Z nested_listrrrr r:`s r:csFddlm}ddlmt||r*|}tfdd|jDS)zmReturns True if xarray object contains only numpy or dask arrays. Expects obj to be Dataset or DataArrayr) DataArrayis_duck_dask_arraycs$g|]}t|jtjp|jqSr)r2rr=rL)rvarr<rr r ssz/contains_only_dask_or_numpy..) Zxarray.core.dataarrayr;Zxarray.core.pycompatr=r2Z_to_temp_datasetr variablesr)r*r;rr<r contains_only_dask_or_numpyhs    r@)modulercCstj|dk S)aChecks whether a module is installed without importing it. Use this for a lightweight check and lazy imports. Parameters ---------- module : str Name of the module. Returns ------- available : bool Whether the module is installed. N) importlibutil find_spec)rArrr module_availablezsrEFcCsnddl}tj|j}tj|d}t}d}|rjt|}| |rj| |rV|rj|j }|d7}q0qjq0|S)aFind the first place in the stack that is not inside xarray. This is unless the code emanates from a test, in which case we would prefer to see the xarray source. This function is taken from pandas. Parameters ---------- test_mode : bool Flag used for testing purposes to switch off the detection of test directories in the stack trace. Returns ------- stacklevel : int First level in the stack that is not part of xarray. rNtestsr) Zxarrayrrdirname__file__r/inspect currentframegetfile startswithf_back)Z test_modeZxrZpkg_dirZtest_dirframenfnamerrr find_stack_levels  rQcCst}tj|||ddS)z?Emit a warning at the user level by inspecting the stack trace.)categoryr%N)rQr&r')messagerRr%rrr emit_user_level_warningsrT)r")T)T)r)r)r)r)F)N)or6 __future__r contextlibr4rBrIrr`rrrsysr&enumrtypingrrrrrr r r r r rrrrrrrZnumpyr=Zpandasr<Zxarray.core.typesrrrrrrr!r)r7rBrKrOrVrUrdrmrorurwryr}rr version_inforZtyping_extensions ImportErrorrr@rrrrrrrrrrrrcontextmanagerrrrrrrrr]rrrrrrrr r#r)r+r*r0r1r8r9_defaultr:r@rErQrTrrrr s#  L        +&         )0,  ) 7 %