def assert_inner_types(parent_type, *dagster_types):
assert set(
list(
map(lambda t: t.name,
resolve_to_config_type(parent_type).inner_types))) == set(
map(lambda x: x.name,
map(resolve_to_config_type, dagster_types)))
def check_using_facing_field_param(obj, param_name, error_context_str):
check.str_param(param_name, 'param_name')
check.str_param(error_context_str, 'error_context_str')
if isinstance(obj, FieldImpl):
return obj
from dagster.core.types.field import resolve_to_config_type
from .type_printer import print_config_type_to_string
config_type = resolve_to_config_type(obj)
if config_type:
raise DagsterInvalidDefinitionError(
('You have passed a config type "{printed_type}" in the parameter '
'"{param_name}" {error_context_str}. '
'You have likely forgot to wrap this type in a Field.').format(
printed_type=print_config_type_to_string(config_type,
with_lines=False),
error_context_str=error_context_str,
param_name=param_name,
))
else:
raise DagsterInvalidDefinitionError(
('You have passed an object {value_repr} of incorrect type '
'"{type_name}" in the parameter "{param_name}" '
'{error_context_str} where a Field was expected.').format(
error_context_str=error_context_str,
param_name=param_name,
value_repr=repr(obj),
type_name=type(obj).__name__,
))
def test_config_int():
int_inst = resolve_to_config_type(Int)
assert evaluate_config(int_inst, 1).success
assert not evaluate_config(int_inst, None).success
assert not evaluate_config(int_inst, 'r').success
assert not int_inst.is_list
assert not int_inst.is_nullable
assert not (int_inst.is_nullable or int_inst.is_list)
def test_config_any():
any_inst = resolve_to_config_type(None)
assert evaluate_config(any_inst, 1).success
assert evaluate_config(any_inst, None).success
assert evaluate_config(any_inst, 'r').success
assert not any_inst.is_list
assert not any_inst.is_nullable
assert any_inst.is_any
def test_config_int():
int_inst = resolve_to_config_type(Int)
assert not validate_config(int_inst, 1)
assert validate_config(int_inst, None)
assert validate_config(int_inst, 'r')
assert not int_inst.is_list
assert not int_inst.is_nullable
assert not (int_inst.is_nullable or int_inst.is_list)
def test_list_nullable_int():
lni = resolve_to_config_type(List(Nullable(Int)))
assert not validate_config(lni, [1])
assert not validate_config(lni, [1, 2])
assert not validate_config(lni, [])
assert not validate_config(lni, [None])
assert not validate_config(lni, [1, None])
assert validate_config(lni, None)
assert validate_config(lni, [1, 'absdf'])
def test_list_int():
list_int = resolve_to_config_type(List(Int))
assert not validate_config(list_int, [1])
assert not validate_config(list_int, [1, 2])
assert not validate_config(list_int, [])
assert validate_config(list_int, [None])
assert validate_config(list_int, [1, None])
assert validate_config(list_int, None)
assert validate_config(list_int, [1, 'absdf'])
def test_list_nullable_int():
lni = resolve_to_config_type(List[Optional[Int]])
assert evaluate_config(lni, [1]).success
assert evaluate_config(lni, [1, 2]).success
assert evaluate_config(lni, []).success
assert evaluate_config(lni, [None]).success
assert evaluate_config(lni, [1, None]).success
assert not evaluate_config(lni, None).success
assert not evaluate_config(lni, [1, 'absdf']).success
def test_list_int():
list_int = resolve_to_config_type(List[Int])
assert evaluate_config(list_int, [1]).success
assert evaluate_config(list_int, [1, 2]).success
assert evaluate_config(list_int, []).success
assert not evaluate_config(list_int, [None]).success
assert not evaluate_config(list_int, [1, None]).success
assert not evaluate_config(list_int, None).success
assert not evaluate_config(list_int, [1, 'absdf']).success
def test_list_of_dict():
inner_dict_dagster_type = Dict({'foo': Field(str)})
list_of_dict_meta = meta_from_dagster_type(List[inner_dict_dagster_type])
assert list_of_dict_meta.key.startswith('List')
assert list_of_dict_meta.inner_type_refs
assert len(list_of_dict_meta.inner_type_refs) == 1
# Both Dict[...] and str are NonGenericTypeRefMetas in this schema
dict_ref = list_of_dict_meta.type_param_refs[0]
assert isinstance(dict_ref, NonGenericTypeRefMeta)
assert dict_ref.key.startswith('Dict')
assert (len(list_of_dict_meta.type_param_refs) == 1
and list_of_dict_meta.type_param_refs[0].key
== resolve_to_config_type(inner_dict_dagster_type).key)
def test_apply_default_values():
scalar_config_type = resolve_to_config_type(String)
assert apply_default_values(scalar_config_type, 'foo') == 'foo'
assert apply_default_values(scalar_config_type, 3) == 3
assert apply_default_values(scalar_config_type, {}) == {}
assert apply_default_values(scalar_config_type, None) is None
enum_config_type = resolve_to_config_type(
Enum('an_enum', [EnumValue('foo'),
EnumValue('bar', python_value=3)]))
assert apply_default_values(enum_config_type, 'foo') == 'foo'
assert apply_default_values(enum_config_type, 'bar') == 3
with pytest.raises(CheckError,
match='config_value should be pre-validated'):
apply_default_values(enum_config_type, 'baz')
with pytest.raises(CheckError,
match='config_value should be pre-validated'):
apply_default_values(enum_config_type, None)
list_config_type = resolve_to_config_type(List[String])
assert apply_default_values(list_config_type, ['foo']) == ['foo']
assert apply_default_values(list_config_type, None) == []
with pytest.raises(CheckError, match='Null list member not caught'):
assert apply_default_values(list_config_type, [None]) == [None]
nullable_list_config_type = resolve_to_config_type(List[Optional[String]])
assert apply_default_values(nullable_list_config_type, ['foo']) == ['foo']
assert apply_default_values(nullable_list_config_type, [None]) == [None]
assert apply_default_values(nullable_list_config_type, None) == []
composite_config_type = resolve_to_config_type(
Dict({
'foo': Field(String),
'bar': Field(Dict({'baz': Field(List[String])})),
'quux': Field(String, is_optional=True, default_value='zip'),
'quiggle': Field(String, is_optional=True),
}))
with pytest.raises(CheckError,
match='Missing non-optional composite member'):
apply_default_values(composite_config_type, {})
with pytest.raises(CheckError,
match='Missing non-optional composite member'):
apply_default_values(composite_config_type, {
'bar': {
'baz': ['giraffe']
},
'quux': 'nimble'
})
with pytest.raises(CheckError,
match='Missing non-optional composite member'):
apply_default_values(composite_config_type, {
'foo': 'zowie',
'quux': 'nimble'
})
assert apply_default_values(composite_config_type, {
'foo': 'zowie',
'bar': {
'baz': ['giraffe']
},
'quux': 'nimble'
}) == {
'foo': 'zowie',
'bar': {
'baz': ['giraffe']
},
'quux': 'nimble'
}
assert apply_default_values(composite_config_type, {
'foo': 'zowie',
'bar': {
'baz': ['giraffe']
}
}) == {
'foo': 'zowie',
'bar': {
'baz': ['giraffe']
},
'quux': 'zip'
}
assert apply_default_values(composite_config_type, {
'foo': 'zowie',
'bar': {
'baz': ['giraffe']
},
'quiggle': 'squiggle'
}) == {
'foo': 'zowie',
'bar': {
'baz': ['giraffe']
},
'quux': 'zip',
'quiggle': 'squiggle'
}
nested_composite_config_type = resolve_to_config_type(
Dict({
'fruts':
Field(
Dict({
'apple':
Field(String),
'banana':
Field(String, is_optional=True),
'potato':
Field(String, is_optional=True, default_value='pie'),
}))
}))
with pytest.raises(CheckError,
match='Missing non-optional composite member'):
apply_default_values(nested_composite_config_type, {'fruts': None})
with pytest.raises(CheckError,
match='Missing non-optional composite member'):
apply_default_values(nested_composite_config_type,
{'fruts': {
'banana': 'good',
'potato': 'bad'
}})
assert apply_default_values(nested_composite_config_type,
{'fruts': {
'apple': 'strawberry'
}}) == {
'fruts': {
'apple': 'strawberry',
'potato': 'pie'
}
}
assert apply_default_values(
nested_composite_config_type,
{'fruts': {
'apple': 'a',
'banana': 'b',
'potato': 'c'
}}) == {
'fruts': {
'apple': 'a',
'banana': 'b',
'potato': 'c'
}
}
any_config_type = resolve_to_config_type(Any)
assert apply_default_values(any_config_type, {'foo': 'bar'}) == {
'foo': 'bar'
}
with pytest.raises(CheckError, match='Unsupported type'):
assert apply_default_values(
ConfigType('gargle', 'bargle', ConfigTypeKind.REGULAR), 3)
selector_config_type = resolve_to_config_type(
Selector({
'one':
Field(String),
'another':
Field(
Dict({
'foo':
Field(String, default_value='bar', is_optional=True)
})),
'yet_another':
Field(String, default_value='quux', is_optional=True),
}))
with pytest.raises(CheckError):
apply_default_values(selector_config_type, 'one')
with pytest.raises(ParameterCheckError):
apply_default_values(selector_config_type, None)
with pytest.raises(ParameterCheckError,
match='Expected dict with single item'):
apply_default_values(selector_config_type, {})
with pytest.raises(CheckError):
apply_default_values(selector_config_type, {
'one': 'foo',
'another': 'bar'
})
assert apply_default_values(selector_config_type, {'one': 'foo'}) == {
'one': 'foo'
}
assert apply_default_values(selector_config_type, {'one': None}) == {
'one': None
}
assert apply_default_values(selector_config_type, {'one': {}}) == {
'one': {}
}
assert apply_default_values(selector_config_type, {'another': {}}) == {
'another': {
'foo': 'bar'
}
}
singleton_selector_config_type = resolve_to_config_type(
Selector({'foo': Field(String, default_value='bar',
is_optional=True)}))
assert apply_default_values(singleton_selector_config_type, None) == {
'foo': 'bar'
}
permissive_dict_config_type = resolve_to_config_type(
PermissiveDict({
'foo':
Field(String),
'bar':
Field(String, default_value='baz', is_optional=True)
}))
with pytest.raises(CheckError,
match='Missing non-optional composite member'):
apply_default_values(permissive_dict_config_type, None)
assert apply_default_values(permissive_dict_config_type, {
'foo': 'wow',
'mau': 'mau'
}) == {
'foo': 'wow',
'bar': 'baz',
'mau': 'mau',
}
def eval_config_value_from_dagster_type(dagster_type, value):
return evaluate_config(resolve_to_config_type(dagster_type), value)
def test_nullable_int():
nullable_int_inst = resolve_to_config_type(Nullable(Int))
assert not validate_config(nullable_int_inst, 1)
assert not validate_config(nullable_int_inst, None)
assert validate_config(nullable_int_inst, 'r')
def test_optional_int():
optional_int_inst = resolve_to_config_type(Optional[Int])
assert evaluate_config(optional_int_inst, 1).success
assert evaluate_config(optional_int_inst, None).success
assert not evaluate_config(optional_int_inst, 'r').success
def meta_from_dagster_type(dagster_type):
return meta_from_config_type(resolve_to_config_type(dagster_type))
