def test_dict_prompting_error_concatenate_different_types(self): schema = ParamSchema.Dict({ "x": ParamSchema.Column(column_types=frozenset({"number"})), "y": ParamSchema.Column(column_types=frozenset({"number"})), }) with self.assertRaises(PromptingError) as cm: self._call_clean_value( schema, { "x": "A", "y": "B" }, input_table_columns=[TEXT("A"), TIMESTAMP("B")], ) self.assertEqual( cm.exception.errors, [ PromptingError.WrongColumnType(["A"], "text", frozenset({"number"})), PromptingError.WrongColumnType(["B"], "timestamp", frozenset({"number"})), ], )
def test_clean_column_happy_path(self): input_shape = TableMetadata(3, [Column("A", ColumnType.Number())]) self.assertEqual( clean_value(ParamSchema.Column(column_types=frozenset({"number"})), "A", input_shape), "A", )
def test_clean_column_missing_becomes_empty_string( self): # TODO make it None self.assertEqual( self._call_clean_value(ParamSchema.Column(), "B", input_table_columns=[TEXT("A")]), "", )
def test_clean_column_prompting_error_convert_to_text(self): with self.assertRaises(PromptingError) as cm: self._call_clean_value( ParamSchema.Column(column_types=frozenset({"text"})), "A", input_table_columns=[NUMBER("A")], ) self.assertEqual( cm.exception.errors, [PromptingError.WrongColumnType(["A"], None, frozenset({"text"}))], )
def test_clean_column_prompting_error_convert_to_number(self): input_shape = TableMetadata(3, [Column("A", ColumnType.Text())]) with self.assertRaises(PromptingError) as cm: clean_value(ParamSchema.Column(column_types=frozenset({"number"})), "A", input_shape) self.assertEqual( cm.exception.errors, [ PromptingError.WrongColumnType(["A"], "text", frozenset({"number"})) ], )
def test_dict_prompting_error(self): input_shape = TableMetadata( 3, [Column("A", ColumnType.Text()), Column("B", ColumnType.Text())]) schema = ParamSchema.Dict({ "col1": ParamSchema.Column(column_types=frozenset({"number"})), "col2": ParamSchema.Column(column_types=frozenset({"timestamp"})), }) with self.assertRaises(PromptingError) as cm: clean_value(schema, {"col1": "A", "col2": "B"}, input_shape) self.assertEqual( cm.exception.errors, [ PromptingError.WrongColumnType(["A"], "text", frozenset({"number"})), PromptingError.WrongColumnType(["B"], "text", frozenset({"timestamp"})), ], )
def test_list_prompting_error_concatenate_different_type_to_text(self): schema = ParamSchema.List(inner_schema=ParamSchema.Column( column_types=frozenset({"text"}))) with self.assertRaises(PromptingError) as cm: self._call_clean_value( schema, ["A", "B"], input_table_columns=[NUMBER("A"), TIMESTAMP("B")]) self.assertEqual( cm.exception.errors, [ PromptingError.WrongColumnType(["A", "B"], None, frozenset({"text"})) ], )
def test_list_prompting_error_concatenate_same_type(self): schema = ParamSchema.List(inner_schema=ParamSchema.Column( column_types=frozenset({"number"}))) with self.assertRaises(PromptingError) as cm: self._call_clean_value(schema, ["A", "B"], input_table_columns=[TEXT("A"), TEXT("B")]) self.assertEqual( cm.exception.errors, [ PromptingError.WrongColumnType(["A", "B"], "text", frozenset({"number"})) ], )
def test_clean_column_prompting_error_convert_to_text(self): # TODO make this _automatic_ instead of quick-fix? # Consider Regex. We probably want to pass the module a text Series # _separately_ from the input DataFrame. That way Regex can output # a new Text column but preserve its input column's data type. # # ... but for now: prompt for a Quick Fix. input_shape = TableMetadata(3, [Column("A", ColumnType.Number())]) with self.assertRaises(PromptingError) as cm: clean_value(ParamSchema.Column(column_types=frozenset({"text"})), "A", input_shape) self.assertEqual( cm.exception.errors, [PromptingError.WrongColumnType(["A"], None, frozenset({"text"}))], )
def _(self, schema: ParamSchema.Multichartseries, value: List[Dict[str, str]]) -> List[Dict[str, str]]: # Recurse to clean_value(ParamSchema.Column) to clear missing columns inner_schema = ParamSchema.Dict({ "color": ParamSchema.String(default="#000000"), "column": ParamSchema.Column(column_types=frozenset(["number"])), }) ret = [] error_agg = PromptingErrorAggregator() for v in value: try: clean_v = self.clean_value(inner_schema, v) if clean_v["column"]: # it's a valid column ret.append(clean_v) except PromptingError as err: error_agg.extend(err.errors) error_agg.raise_if_nonempty() return ret
def test_default(self): # TODO consider changing this to None. [2021-04-20, adamhooper] I think # most/all modules would be compatible. assert S.Column().default == ""
def test_validate_not_string(self): with pytest.raises(ValueError, match="not a string"): S.Column().validate(3)
def test_validate_ok(self): S.Column().validate("A")
def test_clean_column_missing(self): input_shape = TableMetadata(3, [Column("A", ColumnType.Number())]) self.assertEqual(clean_value(ParamSchema.Column(), "B", input_shape), "")
def test_column_without_column_types(): assert parse({"type": "column"}) == ParamSchema.Column(column_types=None)
def test_clean_column_tab_parameter_is_error(self): input_shape = TableMetadata(3, [Column("A", ColumnType.Number())]) with self.assertRaisesRegex( RuntimeError, "Unsupported: fetch column with tab_parameter"): clean_value(ParamSchema.Column(tab_parameter="tab-2"), "A", input_shape)
def test_clean_column_no_input_is_empty(self): self.assertEqual( clean_value(ParamSchema.Column(), "A", TableMetadata()), "")
def test_column_column_types_is_frozenset(): assert parse({ "type": "column", "column_types": ["timestamp", "number"] }) == ParamSchema.Column(column_types=frozenset(["timestamp", "number"]))
def test_clean_column_valid(self): result = self._call_clean_value(ParamSchema.Column(), "A", input_table_columns=[TEXT("A")]) self.assertEqual(result, "A")