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})