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