a jDfQ> @s6ddlmZmZmZmZddlmZmZmZm Z m Z zddl m Z Wn.eyrZzedeWYdZ[n dZ[00ddlmmZddlZddlmZddlZddlmZerddlmZmZgdZGd d d eeZe jej d d d Z!e jej d ddZ"e j#ddgddZ$e je%d ddZ&e&ddde'e'e je(edddZ)e&ddddde jee'e'e'e e'dfe jeee'fdddZ*e j+e$d d!Z,e,Z-ej.ej/d"d"d#e0d$Z1e 2e 3Be,Be1BZ4e jeeefd d%d&Z5e j6dde!e5d'e j7e edfe e je eeeee'ffdfe jej e jeej8d(d)d*Z9e ddd+eee'e e'dfe jeed,d-d.Z:e ddd+eeefe'e e'dfe jeeefd,d/d.Z:e j6ddd+e j7e eeeeeffe'e e'dfe eeeeeffd0d1d.Z:dS)2)HashableIterableMappingSequence) TYPE_CHECKINGAnyProtocolUnionoverloadNzB`xarray.testing.strategies` requires `hypothesis` to be installed.)InvalidArgument) T_DuckArray)_DTypeLikeNested _ShapeLike)supported_dtypespandas_index_dtypesnamesdimension_namesdimension_sizesattrs variablesunique_subset_ofc@s$eZdZddejedddZdS)ArrayStrategyFnrr )shapedtypereturncCsdSN)selfrrrrf/nfs/NAS7/SABIOD/METHODE/ermites/ermites_venv/lib/python3.9/site-packages/xarray/testing/strategies.py__call__#szArrayStrategyFn.__call__N)__name__ __module__ __qualname__stSearchStrategyr rrrrrr"sr)rcCs0tjddtjddBtjddBtjddBS)a Generates only those numpy dtypes which xarray can handle. Use instead of hypothesis.extra.numpy.scalar_dtypes in order to exclude weirder dtypes such as unicode, byte_string, array, or nested dtypes. Also excludes datetimes, which dodges bugs with pandas non-nanosecond datetime overflows. Checks only native endianness. Requires the hypothesis package to be installed. See Also -------- :ref:`testing.hypothesis`_ = endianness)npstinteger_dtypesunsigned_integer_dtypesfloating_dtypesZcomplex_number_dtypesrrrrr+s    rcCsRtjdddtjdddBtjdddBtjdddBtjdddBtjddBS)z Dtypes supported by pandas indexes. Restrict datetime64 and timedelta64 to ns frequency till Xarray relaxes that. r%) @)r'sizesns)r'Z max_periodr&)r(r)r*r+Zdatetime64_dtypesZtimedelta64_dtypesZunicode_string_dtypesrrrrrEs      rLNi) categoriesZ max_codepointcCstjtdddS)z Generates arbitrary string names for dimensions / variables. Requires the hypothesis package to be installed. See Also -------- :ref:`testing.hypothesis`_ min_sizemax_size)r#text_readable_charactersrrrrr\s rZ name_strategymin_dimsmax_dims)r<r=rcCstj|||ddS)at Generates an arbitrary list of valid dimension names. Requires the hypothesis package to be installed. Parameters ---------- name_strategy Strategy for making names. Useful if we need to share this. min_dims Minimum number of dimensions in generated list. max_dims Maximum number of dimensions in generated list. T)elementsr6r7unique)r#listsr;rrrrms rr3 dim_namesr<r=min_sidemax_side)rBr<r=rCrDrcCs,|dur|d}tj|tj||d||dS)a Generates an arbitrary mapping from dimension names to lengths. Requires the hypothesis package to be installed. Parameters ---------- dim_names: strategy generating strings, optional Strategy for generating dimension names. Defaults to the `names` strategy. min_dims: int, optional Minimum number of dimensions in generated list. Default is 1. max_dims: int, optional Maximum number of dimensions in generated list. Default is 3. min_side: int, optional Minimum size of a dimension. Default is 1. max_side: int, optional Minimum size of a dimension. Default is `min_length` + 5. See Also -------- :ref:`testing.hypothesis`_ Nr:)Z min_valueZ max_value)keysvaluesr6r7)r# dictionariesZintegersrArrrrs$ rr4)r7)rDr=rrcCstjtttddddS)z Generates arbitrary valid attributes dictionaries for xarray objects. The generated dictionaries can potentially be recursive. Requires the hypothesis package to be installed. See Also -------- :ref:`testing.hypothesis`_ cSs tt|Sr)r#rG _attr_keys)childrenrrrzattrs..r:)Z max_leaves)r# recursiverGrJ _attr_valuesrrrrrs  r)array_strategy_fndimsrr)drawrPrQrrrc Cst|tjs(|dur(tdt|dt|tjsP|durPtdt|dt|tjsx|durxtdt|d|durtj}nt|stdn|}||}|durB||}t|trt |}tj t |t |d} || } || |d} nJt|t t fr.t |t|}} || |d} ntd t|n0|t } || |d} |tt | t | d}|| } | j| krtd | d | jd | j|krtd |d | jdtj|| ||dS)u Generates arbitrary xarray.Variable objects. Follows the basic signature of the xarray.Variable constructor, but allows passing alternative strategies to generate either numpy-like array data or dimensions. Also allows specifying the shape or dtype of the wrapped array up front. Passing nothing will generate a completely arbitrary Variable (containing a numpy array). Requires the hypothesis package to be installed. Parameters ---------- array_strategy_fn: Callable which returns a strategy generating array-likes, optional Callable must only accept shape and dtype kwargs, and must generate results consistent with its input. If not passed the default is to generate a small numpy array with one of the supported_dtypes. dims: Strategy for generating the dimensions, optional Can either be a strategy for generating a sequence of string dimension names, or a strategy for generating a mapping of string dimension names to integer lengths along each dimension. If provided as a mapping the array shape will be passed to array_strategy_fn. Default is to generate arbitrary dimension names for each axis in data. dtype: Strategy which generates np.dtype objects, optional Will be passed in to array_strategy_fn. Default is to generate any scalar dtype using supported_dtypes. Be aware that this default set of dtypes includes some not strictly allowed by the array API standard. attrs: Strategy which generates dicts, optional Default is to generate a nested attributes dictionary containing arbitrary strings, booleans, integers, Nones, and numpy arrays. Returns ------- variable_strategy Strategy for generating xarray.Variable objects. Raises ------ ValueError If a custom array_strategy_fn returns a strategy which generates an example array inconsistent with the shape & dtype input passed to it. Examples -------- Generate completely arbitrary Variable objects backed by a numpy array: >>> variables().example() # doctest: +SKIP array([43506, -16, -151], dtype=int32) >>> variables().example() # doctest: +SKIP array([[[-10000000., -10000000.], [-10000000., -10000000.]], [[-10000000., -10000000.], [ 0., -10000000.]], [[ 0., -10000000.], [-10000000., inf]], [[ -0., -10000000.], [-10000000., -0.]]], dtype=float32) Attributes: śřĴ: {'ĉ': {'iĥf': array([-30117, -1740], dtype=int16)}} Generate only Variable objects with certain dimension names: >>> variables(dims=st.just(["a", "b"])).example() # doctest: +SKIP array([[ 248, 4294967295, 4294967295], [2412855555, 3514117556, 4294967295], [ 111, 4294967295, 4294967295], [4294967295, 1084434988, 51688], [ 47714, 252, 11207]], dtype=uint32) Generate only Variable objects with certain dimension names and lengths: >>> variables(dims=st.just({"a": 2, "b": 1})).example() # doctest: +SKIP array([[-1.00000000e+007+3.40282347e+038j], [-2.75034266e-225+2.22507386e-311j]]) See Also -------- :ref:`testing.hypothesis`_ Nz_dims must be provided as a hypothesis.strategies.SearchStrategy object (or None), but got type z>. To specify fixed contents, use hypothesis.strategies.just().z`dtype must be provided as a hypothesis.strategies.SearchStrategy object (or None), but got type z`attrs must be provided as a hypothesis.strategies.SearchStrategy object (or None), but got type zarray_strategy_fn must be a Callable that accepts the kwargs dtype and shape and returns a hypothesis strategy which generates corresponding array-like objects.)r<r=rIz@Invalid type returned by dims strategy - drew an object of type z\array_strategy_fn returned an array object with a different shape than it was passed.Passed z, but returned z.Please either specify a consistent shape via the dims kwarg or ensure the array_strategy_fn callable obeys the shape argument passed to it.z\array_strategy_fn returned an array object with a different dtype than it was passed.Passed zPlease either specify a consistent dtype via the dtype kwarg or ensure the array_strategy_fn callable obeys the dtype argument passed to it.)rQdatar) isinstancer#r$r typer(arrayscallablerlist array_shapeslenrdictrEtuplerFrr ValueErrorrxrVariable) rRrPrQrrZ_array_strategy_fnZ_dtypeZ_dimsrBZ valid_shapesZ_shapeZarray_strategy_datarrrrsn^       rr5)objsr6r7rcCsdSrrrar6r7rrrrsrcCsdSrrrbrrrrs)rRrar6r7rcsttstdttdkr0tdttrFtn}|t j t |d||d}ttrfdd|DS|S)a Return a strategy which generates a unique subset of the given objects. Each entry in the output subset will be unique (if input was a sequence) or have a unique key (if it was a mapping). Requires the hypothesis package to be installed. Parameters ---------- objs: Union[Sequence[Hashable], Mapping[Hashable, Any]] Objects from which to sample to produce the subset. min_size: int, optional Minimum size of the returned subset. Default is 0. max_size: int, optional Maximum size of the returned subset. Default is the full length of the input. If set to 0 the result will be an empty mapping. Returns ------- unique_subset_strategy Strategy generating subset of the input. Examples -------- >>> unique_subset_of({"x": 2, "y": 3}).example() # doctest: +SKIP {'y': 3} >>> unique_subset_of(["x", "y"]).example() # doctest: +SKIP ['x'] See Also -------- :ref:`testing.hypothesis`_ zJObject to sample from must be an Iterable or a Mapping, but received type rz'Can't sample from a length-zero object.T)r?r6r7csi|]}||qSrr).0krarr rMz$unique_subset_of..) rTr TypeErrorrUrZr]rrXrEr#r@Z sampled_from)rRrar6r7rEZ subset_keysrrerrs")    );collections.abcrrrrtypingrrrr r Zhypothesis.strategiesZ strategiesr# ImportErroreZhypothesis.extra.numpyextranumpyr(npZhypothesis.errorsr Zxarrayr^Zxarray.core.typesr r r__all__rr$rrr charactersr9strrintrXrrr8Z_readable_stringsrJrVrYZ scalar_dtypesZ _small_arraysnoneZbooleansrOrZ compositeZDrawFnr_rrrrrrs       /  )