def test_whitespace(self):
""" Test constraint parsing with padding whitespace """
constraints = ["percentile = 10", "threshold = 0.1"]
result, _ = parse_constraint_list(constraints)
cdict = result._coord_values
self.assertEqual(cdict["percentile"], 10)
self.assertEqual(cdict["threshold"], 0.1)
def test_whitespace(self):
""" Test constraint parsing with padding whitespace """
constraints = ["percentile = 10", "threshold = 0.1"]
result, _ = parse_constraint_list(constraints)
cdict = result._coord_values
self.assertTrue(islambda(cdict["percentile"]))
self.assertTrue(cdict["percentile"](self.p_crd.cell(0)))
self.assertTrue(islambda(cdict["threshold"]))
self.assertTrue(cdict["threshold"](self.t_crd.cell(0)))
def test_string_constraint(self):
""" Test that a string constraint results in a simple iris constraint,
not a lambda function. This is created via the literal_eval ValueError.
"""
constraints = ["percentile=kittens"]
result, _ = parse_constraint_list(constraints)
cdict = result._coord_values
self.assertFalse(islambda(cdict["percentile"]))
self.assertEqual(cdict["percentile"], "kittens")
self.assertIsInstance(cdict, dict)
def test_basic_no_units(self):
""" Test simple key-value splitting with no units """
result, udict = parse_constraint_list(self.constraints)
self.assertIsInstance(result, iris.Constraint)
self.assertCountEqual(list(result._coord_values.keys()),
["threshold", "percentile"])
cdict = result._coord_values
self.assertEqual(cdict["percentile"], 10)
self.assertEqual(cdict["threshold"], 0.1)
self.assertFalse(udict)
def test_range_constraint(self):
""" Test that a constraint passed in as a range is parsed correctly """
constraints = ["threshold=[0.03:0.1]"]
result, _ = parse_constraint_list(constraints)
self.assertIsInstance(result, iris._constraints.ConstraintCombination)
cdict = result.rhs._coord_values
self.assertEqual(cdict.keys(), ["threshold"])
precip_cube = set_up_precip_probability_cube()
precip_cube.coord("threshold").convert_units("mm h-1")
result_cube = precip_cube.extract(result)
self.assertArrayAlmostEqual(
result_cube.coord("threshold").points, np.array([0.03, 0.1]))
def test_basic_no_units(self):
""" Test simple key-value splitting with no units """
result, udict, _, _ = parse_constraint_list(self.constraints)
self.assertIsInstance(result, iris.Constraint)
self.assertCountEqual(
list(result._coord_values.keys()), ["threshold", "percentile"]
)
cdict = result._coord_values
self.assertTrue(islambda(cdict["percentile"]))
self.assertTrue(cdict["percentile"](self.p_crd.cell(0)))
self.assertFalse(cdict["percentile"](self.t_crd.cell(0)))
self.assertTrue(islambda(cdict["threshold"]))
self.assertTrue(cdict["threshold"](self.t_crd.cell(0)))
self.assertFalse(cdict["threshold"](self.p_crd.cell(0)))
self.assertFalse(udict)
def test_range_constraint(self):
""" Test that a constraint passed in as a range is parsed correctly """
# create input cube
precip_cube = set_up_precip_probability_cube()
threshold_coord = find_threshold_coordinate(precip_cube).name()
precip_cube.coord(threshold_coord).convert_units("mm h-1")
# generate constraints
constraints = ["{}=[0.03:0.1]".format(threshold_coord)]
result, _ = parse_constraint_list(constraints)
self.assertIsInstance(result, iris._constraints.ConstraintCombination)
cdict = result.rhs._coord_values
self.assertEqual(list(cdict.keys()), [threshold_coord])
# extract from input cube
result_cube = precip_cube.extract(result)
self.assertArrayAlmostEqual(
result_cube.coord(threshold_coord).points, np.array([0.03, 0.1]))
def test_list_constraint(self):
""" Test that a list of constraints is parsed correctly """
constraints = ["threshold=[0.1,1.0]"]
result, _ = parse_constraint_list(constraints)
cdict = result._coord_values
self.assertTrue(islambda(cdict["threshold"]))
def test_unmatched_units(self):
""" Test for ValueError if units list does not match constraints """
units = ["mm h-1"]
msg = "units list must match constraints"
with self.assertRaisesRegex(ValueError, msg):
parse_constraint_list(self.constraints, units=units)
def test_some_units(self):
""" Test units list containing "None" elements is correctly parsed """
_, udict = parse_constraint_list(self.constraints, units=self.units)
self.assertEqual(udict["threshold"], "mm h-1")
self.assertNotIn("percentile", udict.keys())
def test_basic_no_units(self):
""" Test simple key-value splitting with no units """
cdict, udict = parse_constraint_list(self.constraints)
self.assertEqual(cdict["percentile"], 10)
self.assertEqual(cdict["threshold"], 0.1)
self.assertFalse(udict)
def test_list_constraint(self):
""" Test that a list of constraints is parsed correctly """
constraints = ["threshold=[0.1,1.0]"]
cdict, _ = parse_constraint_list(constraints)
self.assertEqual(cdict["threshold"], [0.1, 1.0])
def test_longitude_constraint_whitespace(self):
""" Test that the longitude constraint is parsed correctly with whitespace """
constraint = ["longitude = [ 0 : 20 : 2 ]"]
_, _, longitude_constraint, thinning_dict = parse_constraint_list(constraint)
self.assertEqual(longitude_constraint, [0, 20])
self.assertEqual(thinning_dict, {"longitude": 2})
