1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
from datetime import datetime
from typing import Hashable
import numpy as np
import pandas as pd
import pytest
from xarray.coding.cftimeindex import CFTimeIndex
from xarray.core import duck_array_ops, utils
from xarray.core.utils import either_dict_or_kwargs
from . import assert_array_equal, raises_regex, requires_cftime, requires_dask
from .test_coding_times import _all_cftime_date_types
class TestAlias:
def test(self):
def new_method():
pass
old_method = utils.alias(new_method, "old_method")
assert "deprecated" in old_method.__doc__
with pytest.warns(Warning, match="deprecated"):
old_method()
def test_safe_cast_to_index():
dates = pd.date_range("2000-01-01", periods=10)
x = np.arange(5)
td = x * np.timedelta64(1, "D")
for expected, array in [
(dates, dates.values),
(pd.Index(x, dtype=object), x.astype(object)),
(pd.Index(td), td),
(pd.Index(td, dtype=object), td.astype(object)),
]:
actual = utils.safe_cast_to_index(array)
assert_array_equal(expected, actual)
assert expected.dtype == actual.dtype
@requires_cftime
def test_safe_cast_to_index_cftimeindex():
date_types = _all_cftime_date_types()
for date_type in date_types.values():
dates = [date_type(1, 1, day) for day in range(1, 20)]
expected = CFTimeIndex(dates)
actual = utils.safe_cast_to_index(np.array(dates))
assert_array_equal(expected, actual)
assert expected.dtype == actual.dtype
assert isinstance(actual, type(expected))
# Test that datetime.datetime objects are never used in a CFTimeIndex
@requires_cftime
def test_safe_cast_to_index_datetime_datetime():
dates = [datetime(1, 1, day) for day in range(1, 20)]
expected = pd.Index(dates)
actual = utils.safe_cast_to_index(np.array(dates))
assert_array_equal(expected, actual)
assert isinstance(actual, pd.Index)
def test_multiindex_from_product_levels():
result = utils.multiindex_from_product_levels(
[pd.Index(["b", "a"]), pd.Index([1, 3, 2])]
)
np.testing.assert_array_equal(
result.codes, [[0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2]]
)
np.testing.assert_array_equal(result.levels[0], ["b", "a"])
np.testing.assert_array_equal(result.levels[1], [1, 3, 2])
other = pd.MultiIndex.from_product([["b", "a"], [1, 3, 2]])
np.testing.assert_array_equal(result.values, other.values)
def test_multiindex_from_product_levels_non_unique():
result = utils.multiindex_from_product_levels(
[pd.Index(["b", "a"]), pd.Index([1, 1, 2])]
)
np.testing.assert_array_equal(
result.codes, [[0, 0, 0, 1, 1, 1], [0, 0, 1, 0, 0, 1]]
)
np.testing.assert_array_equal(result.levels[0], ["b", "a"])
np.testing.assert_array_equal(result.levels[1], [1, 2])
class TestArrayEquiv:
def test_0d(self):
# verify our work around for pd.isnull not working for 0-dimensional
# object arrays
assert duck_array_ops.array_equiv(0, np.array(0, dtype=object))
assert duck_array_ops.array_equiv(np.nan, np.array(np.nan, dtype=object))
assert not duck_array_ops.array_equiv(0, np.array(1, dtype=object))
class TestDictionaries:
@pytest.fixture(autouse=True)
def setup(self):
self.x = {"a": "A", "b": "B"}
self.y = {"c": "C", "b": "B"}
self.z = {"a": "Z"}
def test_equivalent(self):
assert utils.equivalent(0, 0)
assert utils.equivalent(np.nan, np.nan)
assert utils.equivalent(0, np.array(0.0))
assert utils.equivalent([0], np.array([0]))
assert utils.equivalent(np.array([0]), [0])
assert utils.equivalent(np.arange(3), 1.0 * np.arange(3))
assert not utils.equivalent(0, np.zeros(3))
def test_safe(self):
# should not raise exception:
utils.update_safety_check(self.x, self.y)
def test_unsafe(self):
with pytest.raises(ValueError):
utils.update_safety_check(self.x, self.z)
def test_compat_dict_intersection(self):
assert {"b": "B"} == utils.compat_dict_intersection(self.x, self.y)
assert {} == utils.compat_dict_intersection(self.x, self.z)
def test_compat_dict_union(self):
assert {"a": "A", "b": "B", "c": "C"} == utils.compat_dict_union(self.x, self.y)
with raises_regex(
ValueError,
"unsafe to merge dictionaries without "
"overriding values; conflicting key",
):
utils.compat_dict_union(self.x, self.z)
def test_dict_equiv(self):
x = {}
x["a"] = 3
x["b"] = np.array([1, 2, 3])
y = {}
y["b"] = np.array([1.0, 2.0, 3.0])
y["a"] = 3
assert utils.dict_equiv(x, y) # two nparrays are equal
y["b"] = [1, 2, 3] # np.array not the same as a list
assert utils.dict_equiv(x, y) # nparray == list
x["b"] = [1.0, 2.0, 3.0]
assert utils.dict_equiv(x, y) # list vs. list
x["c"] = None
assert not utils.dict_equiv(x, y) # new key in x
x["c"] = np.nan
y["c"] = np.nan
assert utils.dict_equiv(x, y) # as intended, nan is nan
x["c"] = np.inf
y["c"] = np.inf
assert utils.dict_equiv(x, y) # inf == inf
y = dict(y)
assert utils.dict_equiv(x, y) # different dictionary types are fine
y["b"] = 3 * np.arange(3)
assert not utils.dict_equiv(x, y) # not equal when arrays differ
def test_frozen(self):
x = utils.Frozen(self.x)
with pytest.raises(TypeError):
x["foo"] = "bar"
with pytest.raises(TypeError):
del x["a"]
with pytest.raises(AttributeError):
x.update(self.y)
assert x.mapping == self.x
assert repr(x) in (
"Frozen({'a': 'A', 'b': 'B'})",
"Frozen({'b': 'B', 'a': 'A'})",
)
def test_sorted_keys_dict(self):
x = {"a": 1, "b": 2, "c": 3}
y = utils.SortedKeysDict(x)
assert list(y) == ["a", "b", "c"]
assert repr(utils.SortedKeysDict()) == "SortedKeysDict({})"
def test_repr_object():
obj = utils.ReprObject("foo")
assert repr(obj) == "foo"
assert isinstance(obj, Hashable)
assert not isinstance(obj, str)
def test_repr_object_magic_methods():
o1 = utils.ReprObject("foo")
o2 = utils.ReprObject("foo")
o3 = utils.ReprObject("bar")
o4 = "foo"
assert o1 == o2
assert o1 != o3
assert o1 != o4
assert hash(o1) == hash(o2)
assert hash(o1) != hash(o3)
assert hash(o1) != hash(o4)
def test_is_remote_uri():
assert utils.is_remote_uri("http://example.com")
assert utils.is_remote_uri("https://example.com")
assert not utils.is_remote_uri(" http://example.com")
assert not utils.is_remote_uri("example.nc")
def test_is_grib_path():
assert not utils.is_grib_path("example.nc")
assert not utils.is_grib_path("example.grib ")
assert utils.is_grib_path("example.grib")
assert utils.is_grib_path("example.grib2")
assert utils.is_grib_path("example.grb")
assert utils.is_grib_path("example.grb2")
class Test_is_uniform_and_sorted:
def test_sorted_uniform(self):
assert utils.is_uniform_spaced(np.arange(5))
def test_sorted_not_uniform(self):
assert not utils.is_uniform_spaced([-2, 1, 89])
def test_not_sorted_uniform(self):
assert not utils.is_uniform_spaced([1, -1, 3])
def test_not_sorted_not_uniform(self):
assert not utils.is_uniform_spaced([4, 1, 89])
def test_two_numbers(self):
assert utils.is_uniform_spaced([0, 1.7])
def test_relative_tolerance(self):
assert utils.is_uniform_spaced([0, 0.97, 2], rtol=0.1)
class Test_hashable:
def test_hashable(self):
for v in [False, 1, (2,), (3, 4), "four"]:
assert utils.hashable(v)
for v in [[5, 6], ["seven", "8"], {9: "ten"}]:
assert not utils.hashable(v)
@requires_dask
def test_dask_array_is_scalar():
# regression test for GH1684
import dask.array as da
y = da.arange(8, chunks=4)
assert not utils.is_scalar(y)
def test_hidden_key_dict():
hidden_key = "_hidden_key"
data = {"a": 1, "b": 2, hidden_key: 3}
data_expected = {"a": 1, "b": 2}
hkd = utils.HiddenKeyDict(data, [hidden_key])
assert len(hkd) == 2
assert hidden_key not in hkd
for k, v in data_expected.items():
assert hkd[k] == v
with pytest.raises(KeyError):
hkd[hidden_key]
with pytest.raises(KeyError):
del hkd[hidden_key]
def test_either_dict_or_kwargs():
result = either_dict_or_kwargs(dict(a=1), None, "foo")
expected = dict(a=1)
assert result == expected
result = either_dict_or_kwargs(None, dict(a=1), "foo")
expected = dict(a=1)
assert result == expected
with pytest.raises(ValueError, match=r"foo"):
result = either_dict_or_kwargs(dict(a=1), dict(a=1), "foo")
@pytest.mark.parametrize(
["supplied", "all_", "expected"],
[
(list("abc"), list("abc"), list("abc")),
(["a", ..., "c"], list("abc"), list("abc")),
(["a", ...], list("abc"), list("abc")),
(["c", ...], list("abc"), list("cab")),
([..., "b"], list("abc"), list("acb")),
([...], list("abc"), list("abc")),
],
)
def test_infix_dims(supplied, all_, expected):
result = list(utils.infix_dims(supplied, all_))
assert result == expected
@pytest.mark.parametrize(
["supplied", "all_"], [([..., ...], list("abc")), ([...], list("aac"))]
)
def test_infix_dims_errors(supplied, all_):
with pytest.raises(ValueError):
list(utils.infix_dims(supplied, all_))
|
