def test_enum_2_normalizers():
g = a_b_no_default
g = normalize("a", [1, 2])(g)
g = normalize("b", [3, 4])(g)
assert g(a=1, b=4) == (1, 4)
with pytest.raises(TypeError):
g(a=1)
def test_normalize_duplicates_normalize_2():
# latest normalize overwrite "values" of the previous one.
# TODO: This should perhaps raise a ValueError duplicate normalizer?
func8 = func_param
func8 = normalize("param", ["a", "b"])(func8)
func8 = normalize("param", ["b"])(func8)
assert func8(param="B") == "b"
func8(param="a")
def test_dates_multiple():
date_1 = normalize("d", "date-list(%Y.%m.%d)")(f)
date_2 = normalize("d", "date(%Y.%m.%d)", multiple=True)(f)
date_3 = normalize("d", "date(%Y.%m.%d)", multiple=False)(f)
date_4 = normalize("d", "date-list(%Y.%m.%d)", multiple=False)(f)
assert date_1("20200511") == ["2020.05.11"]
assert date_2("20200512") == ["2020.05.12"]
assert date_3("20200513") == "2020.05.13"
with pytest.raises(ValueError):
date_4("20200514")
def test_order_availability_normalize_int_2():
decorators = [
normalize("step", type=int, multiple=True),
normalize("param", type=str, multiple=True),
normalize("level", type=int, multiple=False),
]
g = level_param_step_no_default
for order in itertools.permutations(decorators):
print(order)
for decorator in order:
g = decorator(g)
print("---", g("1000", "a", "24"))
assert g("1000", "a", "24") == (1000, ["a"], [24])
def test_normalize_duplicates_normalize_1():
func7 = func_param
func7 = normalize("param", ["b"])(func7)
func7 = normalize("param", ["a", "b"])(func7)
assert func7(param="B") == "b"
with pytest.raises(ValueError):
func7(param="a")
func7a = availability(C1)(func7)
assert func7a(param="B") == "b"
with pytest.raises(ValueError):
func7a(param="a")
def test_aliases_grib_paramid_mutiple_false(typ):
_131 = typ(131)
aliases_grib_paramid = normalize(
"x",
type=typ,
aliases={
"u": typ(131),
"v": typ(132)
},
multiple=False,
)(func_x)
assert aliases_grib_paramid("u") == _131
assert aliases_grib_paramid(131) == _131
assert aliases_grib_paramid("131") == _131
# one-element list/tuple
assert aliases_grib_paramid(("131", )) == _131
assert aliases_grib_paramid(["131"]) == _131
# list/tuple
with pytest.raises(TypeError):
aliases_grib_paramid(["131", "v"])
# empty list/tuple
with pytest.raises(TypeError):
aliases_grib_paramid([])
with pytest.raises(TypeError):
aliases_grib_paramid(tuple([]))
def test_aliases_grib_paramid_mutiple_true(typ, _131, _132):
aliases_grib_paramid = normalize(
"x",
type=typ,
aliases={
"u": typ(131),
"v": typ(132)
},
multiple=True,
)(func_x)
# single values
assert aliases_grib_paramid("u") == [_131]
assert aliases_grib_paramid(131) == [_131]
assert aliases_grib_paramid("131") == [_131]
# one-element list/tuple
assert aliases_grib_paramid(("131", )) == [_131]
assert aliases_grib_paramid(["131"]) == [_131]
# list/tuple
assert aliases_grib_paramid(["131", "v"]) == [_131, _132]
assert aliases_grib_paramid([131, "v"]) == [_131, _132]
assert aliases_grib_paramid(["u", "v"]) == [_131, _132]
assert aliases_grib_paramid(("u", "v")) == [_131, _132]
assert aliases_grib_paramid([]) == []
assert aliases_grib_paramid(tuple([])) == []
def test_normalize_dates_from_source():
dates_3 = normalize("d", "date")(f)
dates_list_3 = normalize("d", "date", multiple=True)(f)
source = load_source("file", climetlab_file("docs/examples/test.grib"))
assert dates_3(source[0]) == datetime.datetime(2020, 5, 13, 12, 0)
assert dates_list_3(source[0]) == [datetime.datetime(2020, 5, 13, 12, 0)]
source = load_source("file", climetlab_file("docs/examples/test.nc"))
# For now
with pytest.raises(NotImplementedError):
assert dates_3(source[0]) == datetime.datetime(2020, 5, 13, 12, 0)
assert dates_list_3(
source[0]) == [datetime.datetime(2020, 5, 13, 12, 0)]
def test_enum_dates_formated():
date_formated = normalize("d",
values=["20010512", "20020512"],
type="date",
format="%Y.%m.%d")(f)
assert date_formated("20200513") == "2020.05.13"
def test_enum_multiple_2():
g = normalize("name", ["a", "b", "c"],
multiple=True)(name_default_is_str_a)
assert g((
"a",
"b",
)) == ["a", "b"]
def test_aliases_mutiple_none(typ, _131, _132):
aliases_func = normalize(
"x",
type=typ,
aliases={
"u": _131,
"v": _132
},
)(func_x)
# single values
assert aliases_func("u") == _131
assert aliases_func(131) == _131
assert aliases_func("131") == _131
# one-element list/tuple
assert aliases_func(("131", )) == (_131, )
assert aliases_func(["131"]) == [_131]
# list/tuple
assert aliases_func(["131", "v"]) == [_131, _132]
assert aliases_func([131, "v"]) == [_131, _132]
assert aliases_func(["u", "v"]) == [_131, _132]
assert aliases_func(("u", "v")) == (_131, _132)
assert aliases_func([]) == []
assert aliases_func(tuple([])) == ()
def test_enum_int_1():
g = normalize("name", [1, 0.5, 3], type=int,
multiple=True)(name_default_is_1)
assert g(1) == [1]
assert g(1.0) == [1]
# assert g("1.0") == [1]
assert g("1") == [1]
assert g() == [1]
def test_enum_float_3():
g = normalize("name", type=EnumType([1, 0.5, 3]),
format="%03f")(name_no_default)
assert g(1) == "1.000000"
g = normalize("name",
type=EnumType([1, 0.5, 3]),
format="%03f",
multiple=False)(name_no_default)
assert g(1) == "1.000000"
g = normalize("name",
type=EnumType([1, 0.5, 3]),
format="%03f",
multiple=True)(name_no_default)
with pytest.raises(ValueError, match="Cannot .*"):
assert g(1) == ["1.000000"]
def test_normalize_availability_on_func_1():
func1 = availability(C1)(level_param_step_no_default)
func1 = normalize("param", ["a", "b"])(func1)
assert func1(level=1000, param="a", step="24") == ("1000", "a", "24")
with pytest.raises(ValueError, match="invalid .*"):
func1(level=850, param="a", step="24")
with pytest.raises(ValueError):
func1(level="1032100", param="a", step="24")
def test_enum_aliases_from_file():
enum_aliases_from_file = normalize(
"name",
["a", "b", "c"],
aliases="aliases.json",
)(name_no_default)
assert enum_aliases_from_file("y") == "b"
with pytest.raises(ValueError):
enum_aliases_from_file("unknown")
def test_dates_formated():
date_formated = normalize("d", "date-list(%Y.%m.%d)")(f)
assert date_formated(["20200513",
"20200514"]) == ["2020.05.13", "2020.05.14"]
assert date_formated("20200513") == ["2020.05.13"]
assert date_formated([datetime.datetime(2020, 5, 13, 0,
0)]) == ["2020.05.13"]
assert date_formated([datetime.datetime(2020, 5, 13, 23,
59)]) == ["2020.05.13"]
def __init__(self, **dic):
warnings.warn(
"Deprecated decorator @normalize_arg. Use @normalise on each argument instead."
)
self.decorators = []
for name, values in dic.items():
if isinstance(values, list):
self.decorators.append(normalize(name, values, multiple=True))
continue
if isinstance(values, tuple):
warnings.warn(
"Using tuple to set multiple=False is deprecated in @normalize_arg. Use with multiple=False."
)
self.decorators.append(normalize(name, values, multiple=False))
continue
self.decorators.append(normalize(name, values))
def test_enum_decorator():
g = normalize("name", ("a", "b", "c"))(name_default_is_str_a)
assert g("a") == "a"
assert g("b") == "b"
assert g() == "a"
with pytest.raises(ValueError):
g("z")
assert g(["a", "b"]) == ["a", "b"]
assert g(("a", "b")) == ("a", "b")
assert g(["a"]) == ["a"]
def test_enum_inconsistent_availablity_normalizers():
g = name_no_default
g = normalize("name", type=int)(g)
g = availability(C3)(g)
g(name="50")
with pytest.raises(
ValueError,
match=
"Inconsistent types for availability and normalize for argument 'a'.",
):
g(name="50")
def test_normalize_availability_on_func_2():
func2 = availability(C2)(level_param_step_no_default)
func2 = normalize("param", ["a", "b"])(func2)
# func2 = normalize("level", type=int)(func2)
# func2 = normalize("step", type=int)(func2)
# in C2: {"level": 1000, "param": "a", "step": 24},
assert func2(level=1000, param="a", step=24) == (1000, "a", 24)
assert func2(level="1000", param="a", step=24) == (1000, "a", 24)
with pytest.raises(ValueError, match="invalid .*"):
func2(level="850", param="a", step="24")
with pytest.raises(ValueError):
func2(level="1032100", param="a", step="24")
def test_enum_list_alias_2():
enum_list_alias_2 = normalize(
"name",
[1, 2, 3],
multiple=True,
aliases=lambda x: {
"one": 1,
"o": "one"
}.get(x, x),
)(name_no_default)
assert enum_list_alias_2(1) == [1]
assert enum_list_alias_2("one") == [1]
assert enum_list_alias_2(["one"]) == [1]
assert enum_list_alias_2(["o"]) == [1]
def test_normalize_availability_on_method():
norm_decorator = normalize("param", ["a", "b"])
availability_decorator_1 = availability(C1)
class A:
@norm_decorator
@availability_decorator_1
def method1(self, level, param, step):
return level, param, step
assert A().method1(level="1000", param="a",
step="24") == ("1000", "a", "24")
with pytest.raises(ValueError):
A().method1(level="1032100", param="a", step="24")
def test_enum_alias():
enum_alias = normalize(
"name",
["a", "b", "c"],
multiple=True,
aliases={
"x": "y",
"y": "z",
"z": "a"
},
)(name_no_default)
assert enum_alias("a") == ["a"]
assert enum_alias("b") == ["b"]
assert enum_alias("x") == ["a"]
assert enum_alias("y") == ["a"]
assert enum_alias("z") == ["a"]
def test_dates_formated_from_object():
date_formated = normalize("d", "date", format="%Y.%m.%d")(f)
class CustomDateObject:
def __init__(self, dates):
self.dates = dates
def to_datetime_list(self):
return self.dates
obj = CustomDateObject([
datetime.datetime(2005, 8, 26, 18, 0),
datetime.datetime(2005, 8, 26, 18, 0),
])
assert date_formated(obj) == "2020.05.13"
def test_enum_alias_2():
enum_alias = normalize(
"name",
["a", "b", "c"],
aliases={
"x": "y",
"y": "z",
"z": "a",
"w": "wrong-value"
},
)(name_no_default)
assert enum_alias("a") == "a"
assert enum_alias("b") == "b"
assert enum_alias("x") == "a"
assert enum_alias("y") == "a"
assert enum_alias("z") == "a"
with pytest.raises(ValueError, match=".*wrong-value.*"):
enum_alias("w")
def test_enum_list_alias_1():
enum_list_alias_1 = normalize(
"name",
["a", "b", "c"],
multiple=True,
aliases={
"ab": ["a", "b"],
"z": "a",
"i": ["a", "b"],
"j": "ab",
"bad": ["a", "ab"],
},
)(name_no_default)
assert enum_list_alias_1("a") == ["a"]
assert enum_list_alias_1("b") == ["b"]
assert enum_list_alias_1("ab") == ["a", "b"]
assert enum_list_alias_1("z") == ["a"]
assert enum_list_alias_1(["z", "b"]) == ["a", "b"]
assert enum_list_alias_1("i") == ["a", "b"]
assert enum_list_alias_1("j") == ["a", "b"]
def test_aliases_grib_paramid_mutiple_none():
aliases_grib_paramid = normalize(
"x",
type=str,
aliases="grib-paramid",
)(func_x)
# single values
assert aliases_grib_paramid(131) == "u"
assert aliases_grib_paramid("u") == "u"
assert aliases_grib_paramid("131") == "u"
# one-element list/tuple
assert aliases_grib_paramid(("131",)) == ("u",)
assert aliases_grib_paramid(["131"]) == ["u"]
# list/tuple
assert aliases_grib_paramid(["131", "v"]) == ["u", "v"]
assert aliases_grib_paramid([131, "v"]) == ["u", "v"]
assert aliases_grib_paramid(["u", "v"]) == ["u", "v"]
assert aliases_grib_paramid(("u", "v")) == ("u", "v")
assert aliases_grib_paramid([]) == []
assert aliases_grib_paramid(tuple([])) == ()
def test_aliases_grib_paramid_mutiple_false():
aliases_grib_paramid = normalize(
"x",
type=str,
aliases="grib-paramid",
multiple=False,
)(func_x)
assert aliases_grib_paramid("u") == "u"
assert aliases_grib_paramid(131) == "u"
assert aliases_grib_paramid("131") == "u"
# one-element list/tuple
assert aliases_grib_paramid(("131",)) == "u"
assert aliases_grib_paramid(["131"]) == "u"
# list/tuple
with pytest.raises(TypeError):
aliases_grib_paramid(["131", "v"])
# empty list/tuple
with pytest.raises(TypeError):
aliases_grib_paramid([])
with pytest.raises(TypeError):
aliases_grib_paramid(tuple([]))
def test_dates_formated_1():
date_formated = normalize("d", "date", format="%Y.%m.%d")(f)
assert date_formated("20200513") == "2020.05.13"
def test_enum_no_type():
g = normalize("name", multiple=True)(name_no_default)
assert g(["a", "b"]) == ["a", "b"]
assert g("a") == ["a"]
