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