def apply_default_values_to_selector(selector_type, config_value):
check.param_invariant(selector_type.is_selector, 'selector_type')
if config_value:
check.invariant(config_value and len(config_value) == 1)
field_name, incoming_field_value = single_item(config_value)
else:
field_name, field_def = single_item(selector_type.fields)
incoming_field_value = field_def.default_value if field_def.default_provided else None
parent_field = selector_type.fields[field_name]
field_value = apply_default_values(parent_field.config_type,
incoming_field_value)
return {field_name: field_value}
def _is_selector_field_optional(config_type):
check.inst_param(config_type, 'config_type', ConfigType)
if len(config_type.fields) > 1:
return False
else:
_name, field = single_item(config_type.fields)
return field.is_optional
def define_context_context_cls(pipeline_name, context_definitions):
check.str_param(pipeline_name, 'pipeline_name')
check.dict_param(
context_definitions,
'context_definitions',
key_type=str,
value_type=PipelineContextDefinition,
)
full_type_name = '{pipeline_name}.ContextConfig'.format(
pipeline_name=pipeline_name)
field_dict = {}
if len(context_definitions) == 1:
context_name, context_definition = single_item(context_definitions)
field_dict[context_name] = Field(
define_specific_context_cls(pipeline_name, context_name,
context_definition))
else:
for context_name, context_definition in context_definitions.items():
field_dict[context_name] = Field(
define_specific_context_cls(pipeline_name, context_name,
context_definition),
is_optional=True,
)
return SystemNamedSelector(full_type_name, field_dict)
def construct_context_config(config_value):
context_name, context_value = single_item(config_value)
return ContextConfig(
name=context_name,
config=context_value.get('config'),
resources=context_value['resources'],
persistence=context_value['persistence'],
)
def validate_selector_config_value(selector_type, config_value, stack):
check.param_invariant(selector_type.is_selector, 'selector_type')
check.inst_param(stack, 'stack', EvaluationStack)
if config_value and not isinstance(config_value, dict):
yield EvaluationError(
stack=stack,
reason=DagsterEvaluationErrorReason.RUNTIME_TYPE_MISMATCH,
message='Value for selector type {type_name} must be a dict'.
format(type_name=selector_type.name),
error_data=RuntimeMismatchErrorData(config_type=selector_type,
value_rep=repr(config_value)),
)
return
if config_value and len(config_value) > 1:
incoming_fields = sorted(list(config_value.keys()))
defined_fields = sorted(list(selector_type.fields.keys()))
yield EvaluationError(
stack=stack,
reason=DagsterEvaluationErrorReason.SELECTOR_FIELD_ERROR,
message=
('You can only specify a single field {path_msg}. You specified {incoming_fields}. '
'The available fields are {defined_fields}').format(
incoming_fields=incoming_fields,
defined_fields=defined_fields,
path_msg=_get_friendly_path_msg(stack),
),
error_data=SelectorTypeErrorData(dagster_type=selector_type,
incoming_fields=incoming_fields),
)
return
elif not config_value:
defined_fields = sorted(list(selector_type.fields.keys()))
if len(selector_type.fields) > 1:
yield EvaluationError(
stack=stack,
reason=DagsterEvaluationErrorReason.SELECTOR_FIELD_ERROR,
message=
('Must specify a field {path_msg} if more than one field is defined. '
'Defined fields: {defined_fields}').format(
defined_fields=defined_fields,
path_msg=_get_friendly_path_msg(stack)),
error_data=SelectorTypeErrorData(dagster_type=selector_type,
incoming_fields=[]),
)
return
field_name, field_def = single_item(selector_type.fields)
if not field_def.is_optional:
yield EvaluationError(
stack=stack,
reason=DagsterEvaluationErrorReason.SELECTOR_FIELD_ERROR,
message=
('Must specify the required field {path_msg}. Defined fields: {defined_fields}'
).format(defined_fields=defined_fields,
path_msg=_get_friendly_path_msg(stack)),
error_data=SelectorTypeErrorData(dagster_type=selector_type,
incoming_fields=[]),
)
return
incoming_field_value = field_def.default_value if field_def.default_provided else None
else:
check.invariant(config_value and len(config_value) == 1)
field_name, incoming_field_value = single_item(config_value)
if field_name not in selector_type.fields:
yield create_field_not_defined_error(selector_type, stack,
field_name)
return
parent_field = selector_type.fields[field_name]
for error in _validate_config(
parent_field.config_type,
incoming_field_value,
stack_with_field(stack, field_name, parent_field),
):
yield error
def construct_storage_config(config_value):
check.opt_dict_param(config_value, 'config_value', key_type=str)
if config_value:
storage_mode, storage_config = single_item(config_value)
return StorageConfig(storage_mode, storage_config)
return StorageConfig(None, None)
def _selector(context, config_value):
selector_key, selector_value = single_item(config_value)
return func(context, selector_key, selector_value)
def from_dict(config=None):
check.opt_dict_param(config, 'config', key_type=str)
if config:
system_storage_name, system_storage_config = single_item(config)
return StorageConfig(system_storage_name, system_storage_config.get('config'))
return StorageConfig(None, None)
def _selector(config_value, runtime_value):
selector_key, selector_value = single_item(config_value)
return func(selector_key, selector_value, runtime_value)
def from_dict(config=None):
check.opt_dict_param(config, 'config', key_type=str)
if config:
storage_mode, storage_config = single_item(config)
return StorageConfig(storage_mode, storage_config)
return StorageConfig(None, None)
