def infer_input_definitions_for_composite_solid(solid_name, fn):
signature = funcsigs.signature(fn)
params = list(signature.parameters.values())
descriptions = _infer_input_description_from_docstring(fn)
defs = _infer_inputs_from_params(
params, "@composite_solid", solid_name, descriptions=descriptions
)
return defs
def infer_input_props(fn: Callable,
has_context_arg: bool) -> List[InferredInputProps]:
signature = funcsigs.signature(fn)
params = list(signature.parameters.values())
descriptions = _infer_input_description_from_docstring(fn)
params_to_infer = params[1:] if has_context_arg else params
defs = _infer_inputs_from_params(params_to_infer,
descriptions=descriptions)
return defs
def infer_input_definitions_for_graph(decorator_name, solid_name, fn):
signature = funcsigs.signature(fn)
params = list(signature.parameters.values())
descriptions = _infer_input_description_from_docstring(fn)
defs = _infer_inputs_from_params(params,
decorator_name,
solid_name,
descriptions=descriptions)
return defs
def infer_output_props(fn: Callable) -> InferredOutputProps:
signature = funcsigs.signature(fn)
annotation = None
if not inspect.isgeneratorfunction(fn):
annotation = _coerce_annotation(signature.return_annotation)
return InferredOutputProps(
annotation=annotation,
description=_infer_output_description_from_docstring(fn),
)
def infer_output_definitions(decorator_name, solid_name, fn):
signature = funcsigs.signature(fn)
try:
description = _infer_output_description_from_docstring(fn)
return [
OutputDefinition()
if signature.return_annotation is funcsigs.Signature.empty
else OutputDefinition(signature.return_annotation, description=description)
]
except CheckError as type_error:
raise DagsterInvalidDefinitionError(
"Error inferring Dagster type for return type "
f'"{signature.return_annotation}" from {decorator_name} "{solid_name}". '
f"Correct the issue or explicitly pass definitions to {decorator_name}."
) from type_error
def infer_output_definitions(decorator_name, solid_name, fn):
signature = funcsigs.signature(fn)
try:
return [
OutputDefinition()
if signature.return_annotation is funcsigs.Signature.empty else
OutputDefinition(signature.return_annotation)
]
except CheckError as type_error:
six.raise_from(
DagsterInvalidDefinitionError(
'Error inferring Dagster type for return type '
'"{type_annotation}" from {decorator} "{solid}". '
'Correct the issue or explicitly pass definitions to {decorator}.'
.format(
decorator=decorator_name,
solid=solid_name,
type_annotation=signature.return_annotation,
)),
type_error,
)
def has_explicit_return_type(fn: Callable) -> bool:
signature = funcsigs.signature(fn)
return not signature.return_annotation is funcsigs.Signature.empty
def _infer_output_type(fn):
signature = funcsigs.signature(fn)
return signature.return_annotation
def _infer_kwarg_types(fn):
signature = funcsigs.signature(fn)
params = signature.parameters.values()
return OrderedDict((param.name, param.annotation) for param in params)
def has_explicit_return_type(fn):
signature = funcsigs.signature(fn)
return not signature.return_annotation is funcsigs.Signature.empty
def infer_input_definitions_for_solid(solid_name, fn):
signature = funcsigs.signature(fn)
params = list(signature.parameters.values())
return _infer_inputs_from_params(params[1:], '@solid', solid_name)
def get_function_params(fn: Callable[..., Any]) -> List[funcsigs.Parameter]:
return list(funcsigs.signature(fn).parameters.values())
def split_function_parameters(fn, expected_positionals):
check.callable_param(fn, "fn")
check.list_param(expected_positionals, "expected_positionals", str)
fn_params = list(funcsigs.signature(fn).parameters.values())
return fn_params[0:len(expected_positionals
)], fn_params[len(expected_positionals):]
