def test_param_schema_implicit(self):
mv = ModuleVersion.create_or_replace_from_spec(
{
"id_name":
"x",
"name":
"x",
"category":
"Clean",
"parameters": [
{
"id_name": "foo",
"type": "string",
"default": "X"
},
{
"id_name": "bar",
"type": "secret",
"secret_logic": {
"provider": "oauth",
"service": "google"
},
},
{
"id_name":
"baz",
"type":
"menu",
"options": [
{
"value": "a",
"label": "A"
},
"separator",
{
"value": "c",
"label": "C"
},
],
"default":
"c",
},
],
},
source_version_hash="1.0",
)
self.assertEqual(
repr(mv.param_schema),
repr(
ParamDType.Dict({
"foo":
ParamDType.String(default="X"),
# secret is not in param_schema
"baz":
ParamDType.Enum(choices=frozenset({"a", "c"}),
default="c"),
})),
)
def test_param_schema_implicit(self):
mv = ModuleVersion.create_or_replace_from_spec(
{
'id_name':
'x',
'name':
'x',
'category':
'Clean',
'parameters': [
{
'id_name': 'foo',
'type': 'string',
'default': 'X'
},
{
'id_name': 'bar',
'type': 'secret',
'secret_logic': {
'provider': 'oauth',
'service': 'google'
}
},
{
'id_name':
'baz',
'type':
'menu',
'options': [
{
'value': 'a',
'label': 'A'
},
'separator',
{
'value': 'c',
'label': 'C'
},
],
'default':
'c'
},
]
},
source_version_hash='1.0')
self.assertEqual(
repr(mv.param_schema),
repr(
ParamDType.Dict({
'foo':
ParamDType.String(default='X'),
# secret is not in param_schema
'baz':
ParamDType.Enum(choices=frozenset({'a', 'c'}),
default='c'),
})))
def test_clean_normal_dict(self):
input_shape = TableShape(3, [Column("A", ColumnType.NUMBER())])
schema = ParamDType.Dict(
{"str": ParamDType.String(), "int": ParamDType.Integer()}
)
value = {"str": "foo", "int": 3}
expected = dict(value) # no-op
result = clean_value(schema, value, input_shape)
self.assertEqual(result, expected)
def test_clean_normal_dict(self):
context = RenderContext(None, None, None, None, None)
schema = ParamDType.Dict({
'str': ParamDType.String(),
'int': ParamDType.Integer(),
})
value = {'str': 'foo', 'int': 3}
expected = dict(value) # no-op
result = clean_value(schema, value, context)
self.assertEqual(result, expected)
def test_clean_normal_dict(self):
input_shape = TableShape(3, [Column('A', ColumnType.NUMBER())])
schema = ParamDType.Dict({
'str': ParamDType.String(),
'int': ParamDType.Integer(),
})
value = {'str': 'foo', 'int': 3}
expected = dict(value) # no-op
result = clean_value(schema, value, input_shape)
self.assertEqual(result, expected)
def test_map_parse(self):
dtype = ParamDType.parse({
'type': 'map',
'value_dtype': {
'type': 'dict', # test nesting
'properties': {
'foo': {'type': 'string'},
},
},
})
self.assertEqual(repr(dtype), repr(ParamDType.Map(
value_dtype=ParamDType.Dict(properties={
'foo': ParamDType.String(),
})
)))
def test_map_parse(self):
dtype = ParamDType.parse(
{
"type": "map",
"value_dtype": {
"type": "dict", # test nesting
"properties": {"foo": {"type": "string"}},
},
}
)
self.assertEqual(
repr(dtype),
repr(
ParamDType.Map(
value_dtype=ParamDType.Dict(properties={"foo": ParamDType.String()})
)
),
)
def test_param_schema_explicit(self):
mv = ModuleVersion.create_or_replace_from_spec(
{
"id_name": "x",
"name": "x",
"category": "Clean",
"parameters": [{
"id_name": "whee",
"type": "custom"
}],
"param_schema": {
"id_name": {
"type": "dict",
"properties": {
"x": {
"type": "integer"
},
"y": {
"type": "string",
"default": "X"
},
},
}
},
},
source_version_hash="1.0",
)
self.assertEqual(
repr(mv.param_schema),
repr(
ParamDType.Dict({
"id_name":
ParamDType.Dict({
"x": ParamDType.Integer(),
"y": ParamDType.String(default="X"),
})
})),
)
def test_param_schema_explicit(self):
mv = ModuleVersion.create_or_replace_from_spec({
'id_name': 'x', 'name': 'x', 'category': 'Clean',
'parameters': [
{'id_name': 'whee', 'type': 'custom'}
],
'param_schema': {
'id_name': {
'type': 'dict',
'properties': {
'x': {'type': 'integer'},
'y': {'type': 'string', 'default': 'X'},
},
},
},
}, source_version_hash='1.0')
self.assertEqual(repr(mv.param_schema), repr(ParamDType.Dict({
'id_name': ParamDType.Dict({
'x': ParamDType.Integer(),
'y': ParamDType.String(default='X'),
}),
})))
def test_map_coerce_dict_wrong_value_type(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = dtype.coerce({'a': 1, 'b': None})
self.assertEqual(value, {'a': '1', 'b': ''})
def test_map_coerce_non_dict(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = dtype.coerce([1, 2, 3])
self.assertEqual(value, {})
def test_map_coerce_none(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = dtype.coerce(None)
self.assertEqual(value, {})
def test_map_validate_bad_value_dtype(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = {'a': 1, 'c': 2}
with self.assertRaises(ValueError):
dtype.validate(value)
def test_map_validate_ok(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = {'a': 'b', 'c': 'd'}
dtype.validate(value)
def test_map_coerce_dict_wrong_value_type(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = dtype.coerce({"a": 1, "b": None})
self.assertEqual(value, {"a": "1", "b": ""})
def test_map_validate_ok(self):
dtype = ParamDType.Map(value_dtype=ParamDType.String())
value = {"a": "b", "c": "d"}
dtype.validate(value)
