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"]