def build_it(vars_to_dims_):
all_dims = list(
set(sum((list(dd) for dd in vars_to_dims_.values()), [])))
ds = fixed_datasets(vars_to_dims_)
vars_ = subset_lists(list(vars_to_dims_.keys()))
dims = subset_lists(all_dims)
return tuples(ds, vars_, dims)
def test_fixed_datasets(vars_to_dims, sizes, data):
elements = None
coords_elements = None
min_side, max_side = sizes
# special dims just filled with dim name on coords as test case
all_dims = sorted(set(sum((list(dd) for dd in vars_to_dims.values()), [])))
special_dims = data.draw(hxr.subset_lists(all_dims))
coords_st = {
dd: lists(just(dd), min_side, max_side)
for dd in special_dims
}
dtype_d = data.draw(
fixed_dictionaries({vv: dtypes()
for vv in vars_to_dims}))
S = hxr.fixed_datasets(vars_to_dims, dtype_d, elements, coords_elements,
min_side, max_side, coords_st)
ds = data.draw(S)
assert list(ds) == list(vars_to_dims.keys())
assert all(ds[vv].dims == tuple(vars_to_dims[vv]) for vv in vars_to_dims)
assert all(ds[vv].dtype == np.dtype(dtype_d[vv]) for vv in vars_to_dims)
assert all(
all(ss == dd for ss in ds.coords[dd].values.tolist())
for dd in special_dims)
for dd in all_dims:
L = ds.coords[dd].values.tolist()
assert len(L) >= min_side
assert (max_side is None) or (len(L) <= max_side)
assert (dd in special_dims) or all(isinstance(ss, int) for ss in L)
assert (dd in special_dims) or len(set(L)) == len(L)
def test_fixed_dataarrays(dims, dtype, sizes, data):
elements = None
coords_elements = None
min_side, max_side = sizes
# special dims just filled with dim name on coords as test case
special_dims = data.draw(hxr.subset_lists(dims))
coords_st = {
dd: lists(just(dd), min_side, max_side)
for dd in special_dims
}
S = hxr.fixed_dataarrays(dims, dtype, elements, coords_elements, min_side,
max_side, coords_st)
da = data.draw(S)
assert da.dims == tuple(dims)
assert all(ss >= min_side for ss in da.sizes.values())
assert (max_side is None) or all(ss <= max_side
for ss in da.sizes.values())
assert da.dtype == np.dtype(dtype)
assert all(
all(ss == dd for ss in da.coords[dd].values.tolist())
for dd in special_dims)
for dd in dims:
L = da.coords[dd].values.tolist()
assert (dd in special_dims) or all(isinstance(ss, int) for ss in L)
assert (dd in special_dims) or (len(set(L)) == len(L))
def test_xr_coords_dicts(dims, sizes, unique_coords, data):
elements = None
min_side, max_side = sizes
# special dims just filled with dim name on coords as test case
special_dims = data.draw(hxr.subset_lists(dims))
coords_st = {
dd: lists(just(dd), min_side, max_side)
for dd in special_dims
}
S = hxr.xr_coords_dicts(dims, elements, min_side, max_side, unique_coords,
coords_st)
D = data.draw(S)
assert list(D.keys()) == dims
assert all(min_side <= len(cc) for cc in D.values())
assert (max_side is None) or all(max_side >= len(cc) for cc in D.values())
assert all((dd in special_dims) or all(isinstance(ss, int) for ss in L)
for dd, L in D.items())
assert all(all(ss == dd for ss in D[dd]) for dd in special_dims)
if unique_coords:
for dd, cc in D.items():
assert (dd in special_dims) or (len(set(cc)) == len(cc))
def test_subset_lists_empty(L, sizes, data):
min_size, max_size = sizes
S = hxr.subset_lists([], min_size=0, max_size=max_size)
L2 = data.draw(S)
assert len(L2) == 0
assert L2 == []
def build_it(vars_to_dims_):
all_dims = list(
set(sum((list(dd) for dd in vars_to_dims_.values()), [])))
ds = fixed_datasets(vars_to_dims_)
dims = subset_lists(all_dims)
vars_ = sampled_from(list(vars_to_dims_.keys()))
vars_dict = dictionaries(vars_, dims, dict_class=OrderedDict)
vars_dict = vars_dict.map(OrderedDict.items).map(list)
return tuples(ds, vars_dict, just(all_dims))
def test_subset_lists(L, sizes, data):
min_size, max_size = sizes
assume(min_size <= len(set(L)))
S = hxr.subset_lists(L, min_size, max_size)
L2 = data.draw(S)
n = len(L2)
assert n >= min_size
assert (max_size is None) or (n <= max_size)
assert set(L2).issubset(set(L))