def from_builtin_enum(builtin_enum):
check.invariant(BuiltinEnum.contains(builtin_enum),
"must be member of BuiltinEnum")
return _RUNTIME_MAP[builtin_enum]
def is_callable_valid_config_arg(config):
return BuiltinEnum.contains(config) or is_supported_config_python_builtin(config)
def resolve_to_config_type(dagster_type):
from .field_utils import convert_fields_to_dict_type
# Short circuit if it's already a Config Type
if isinstance(dagster_type, ConfigType):
return dagster_type
if isinstance(dagster_type, dict):
return convert_fields_to_dict_type(dagster_type)
if isinstance(dagster_type, list):
if len(dagster_type) != 1:
raise DagsterInvalidDefinitionError(
"Array specifications must only be of length 1")
inner_type = resolve_to_config_type(dagster_type[0])
if not inner_type:
raise DagsterInvalidDefinitionError(
"Invalid member of array specification: {value} in list {the_list}"
.format(value=repr(dagster_type[0]), the_list=dagster_type))
return Array(inner_type)
from dagster.core.types.dagster_type import DagsterType, List, ListType
from dagster.core.types.python_set import Set, _TypedPythonSet
from dagster.core.types.python_tuple import Tuple, _TypedPythonTuple
if _is_config_type_class(dagster_type):
check.param_invariant(
False,
"dagster_type",
"Cannot pass a config type class to resolve_to_config_type. Got {dagster_type}"
.format(dagster_type=dagster_type),
)
if isinstance(dagster_type, type) and issubclass(dagster_type,
DagsterType):
raise DagsterInvalidDefinitionError(
"You have passed a DagsterType class {dagster_type} to the config system. "
"The DagsterType and config schema systems are separate. "
"Valid config values are:\n{desc}".format(
dagster_type=repr(dagster_type),
desc=VALID_CONFIG_DESC,
))
if is_typing_type(dagster_type):
raise DagsterInvalidDefinitionError((
"You have passed in {dagster_type} to the config system. Types from "
"the typing module in python are not allowed in the config system. "
"You must use types that are imported from dagster or primitive types "
"such as bool, int, etc.").format(dagster_type=dagster_type))
if dagster_type is List or isinstance(dagster_type, ListType):
raise DagsterInvalidDefinitionError(
"Cannot use List in the context of config. " +
helpful_list_error_string())
if dagster_type is Set or isinstance(dagster_type, _TypedPythonSet):
raise DagsterInvalidDefinitionError(
"Cannot use Set in the context of a config field. " +
helpful_list_error_string())
if dagster_type is Tuple or isinstance(dagster_type, _TypedPythonTuple):
raise DagsterInvalidDefinitionError(
"Cannot use Tuple in the context of a config field. " +
helpful_list_error_string())
if isinstance(dagster_type, DagsterType):
raise DagsterInvalidDefinitionError((
"You have passed an instance of DagsterType {type_name} to the config "
"system (Repr of type: {dagster_type}). "
"The DagsterType and config schema systems are separate. "
"Valid config values are:\n{desc}").format(
type_name=dagster_type.display_name,
dagster_type=repr(dagster_type),
desc=VALID_CONFIG_DESC,
), )
# If we are passed here either:
# 1) We have been passed a python builtin
# 2) We have been a dagster wrapping type that needs to be convert its config variant
# e.g. dagster.List
# 2) We have been passed an invalid thing. We return False to signify this. It is
# up to callers to report a reasonable error.
from dagster.primitive_mapping import (
remap_python_builtin_for_config,
is_supported_config_python_builtin,
)
if is_supported_config_python_builtin(dagster_type):
return remap_python_builtin_for_config(dagster_type)
if dagster_type is None:
return ConfigAnyInstance
if BuiltinEnum.contains(dagster_type):
return ConfigType.from_builtin_enum(dagster_type)
# This means that this is an error and we are return False to a callsite
# We do the error reporting there because those callsites have more context
return False
def resolve_dagster_type(dagster_type):
# circular dep
from .python_dict import PythonDict, Dict
from .python_set import PythonSet, DagsterSetApi
from .python_tuple import PythonTuple, DagsterTupleApi
from .transform_typing import transform_typing_type
from dagster.config.config_type import ConfigType
from dagster.primitive_mapping import (
remap_python_builtin_for_runtime,
is_supported_runtime_python_builtin,
)
from dagster.utils.typing_api import is_typing_type
check.invariant(
not (isinstance(dagster_type, type) and issubclass(dagster_type, ConfigType)),
'Cannot resolve a config type to a runtime type',
)
check.invariant(
not (isinstance(dagster_type, type) and issubclass(dagster_type, DagsterType)),
'Do not pass runtime type classes. Got {}'.format(dagster_type),
)
# First check to see if it part of python's typing library
if is_typing_type(dagster_type):
dagster_type = transform_typing_type(dagster_type)
if isinstance(dagster_type, DagsterType):
return dagster_type
# Test for unhashable objects -- this is if, for instance, someone has passed us an instance of
# a dict where they meant to pass dict or Dict, etc.
try:
hash(dagster_type)
except TypeError:
raise DagsterInvalidDefinitionError(
DAGSTER_INVALID_TYPE_ERROR_MESSAGE.format(
additional_msg=(
', which isn\'t hashable. Did you pass an instance of a type instead of '
'the type?'
),
dagster_type=str(dagster_type),
)
)
if is_supported_runtime_python_builtin(dagster_type):
return remap_python_builtin_for_runtime(dagster_type)
if dagster_type is None:
return Any
if dagster_type in _PYTHON_TYPE_TO_DAGSTER_TYPE_MAPPING_REGISTRY:
return _PYTHON_TYPE_TO_DAGSTER_TYPE_MAPPING_REGISTRY[dagster_type]
if dagster_type is Dict:
return PythonDict
if isinstance(dagster_type, DagsterTupleApi):
return PythonTuple
if isinstance(dagster_type, DagsterSetApi):
return PythonSet
if isinstance(dagster_type, DagsterListApi):
return List(Any)
if BuiltinEnum.contains(dagster_type):
return DagsterType.from_builtin_enum(dagster_type)
if not isinstance(dagster_type, type):
raise DagsterInvalidDefinitionError(
DAGSTER_INVALID_TYPE_ERROR_MESSAGE.format(
dagster_type=str(dagster_type), additional_msg='.'
)
)
raise DagsterInvalidDefinitionError(
'{dagster_type} is not a valid dagster type.'.format(dagster_type=dagster_type)
)
def is_callable_valid_config_arg(
config: Union[Callable[..., Any], Dict[str, Any]]) -> bool:
return BuiltinEnum.contains(config) or is_supported_config_python_builtin(
config)