class DauphinStartSubplanExecutionSuccess(dauphin.ObjectType):
class Meta:
name = 'StartSubplanExecutionSuccess'
pipeline = dauphin.Field(dauphin.NonNull('Pipeline'))
has_failures = dauphin.Field(dauphin.NonNull(dauphin.Boolean))
step_results = dauphin.non_null_list(DauphinStepResult)
class DauphinStepSuccessResult(dauphin.ObjectType):
class Meta:
name = 'StepSuccessResult'
interfaces = (DauphinStepResult, )
output_name = dauphin.Field(dauphin.NonNull(dauphin.String))
value_repr = dauphin.Field(dauphin.NonNull(dauphin.String))
class DauphinExecutionStep(dauphin.ObjectType):
class Meta:
name = 'ExecutionStep'
name = dauphin.NonNull(dauphin.String)
inputs = dauphin.non_null_list('ExecutionStepInput')
outputs = dauphin.non_null_list('ExecutionStepOutput')
solid = dauphin.NonNull('Solid')
tag = dauphin.NonNull('StepTag')
def __init__(self, execution_step):
super(DauphinExecutionStep, self).__init__()
self.execution_step = check.inst_param(execution_step,
'execution_step', ExecutionStep)
def resolve_inputs(self, info):
return [
info.schema.type_named('ExecutionStepInput')(inp)
for inp in self.execution_step.step_inputs
]
def resolve_outputs(self, info):
return [
info.schema.type_named('ExecutionStepOutput')(out)
for out in self.execution_step.step_outputs
]
def resolve_name(self, _info):
return self.execution_step.key
def resolve_solid(self, info):
return info.schema.type_named('Solid')(self.execution_step.solid)
def resolve_tag(self, _info):
return self.execution_step.tag
class DauphinConfigTypeNotFoundError(dauphin.ObjectType):
class Meta:
name = 'ConfigTypeNotFoundError'
interfaces = (DauphinError, )
pipeline = dauphin.NonNull('Pipeline')
config_type_name = dauphin.NonNull(dauphin.String)
class DauphinPipelineRun(dauphin.ObjectType):
class Meta:
name = 'PipelineRun'
runId = dauphin.NonNull(dauphin.String)
status = dauphin.NonNull('PipelineRunStatus')
pipeline = dauphin.NonNull('Pipeline')
logs = dauphin.NonNull('LogMessageConnection')
executionPlan = dauphin.NonNull('ExecutionPlan')
def __init__(self, pipeline_run):
super(DauphinPipelineRun, self).__init__(
runId=pipeline_run.run_id, status=pipeline_run.status
)
self._pipeline_run = check.inst_param(pipeline_run, 'pipeline_run', PipelineRun)
def resolve_pipeline(self, info):
return model.get_pipeline_or_raise(info, self._pipeline_run.selector)
def resolve_logs(self, info):
return info.schema.type_named('LogMessageConnection')(self._pipeline_run)
def resolve_executionPlan(self, info):
pipeline = self.resolve_pipeline(info)
return info.schema.type_named('ExecutionPlan')(pipeline, self._pipeline_run.execution_plan)
class DauphinInput(dauphin.ObjectType):
class Meta:
name = 'Input'
solid = dauphin.NonNull('Solid')
definition = dauphin.NonNull('InputDefinition')
depends_on = dauphin.Field('Output')
def __init__(self, input_handle, solid):
super(DauphinInput, self).__init__(solid=solid)
self._solid = check.inst_param(solid, 'solid', DauphinSolid)
self._input_handle = check.inst_param(input_handle, 'input_handle', SolidInputHandle)
def resolve_definition(self, graphene_info):
return graphene_info.schema.type_named('InputDefinition')(
self._input_handle.input_def, self._solid.resolve_definition(graphene_info)
)
def resolve_depends_on(self, graphene_info):
if self._input_handle in self._solid.depends_on:
return graphene_info.schema.type_named('Output')(
self._solid.depends_on[self._input_handle],
graphene_info.schema.type_named('Solid')(
self._solid.depends_on[self._input_handle].solid
),
)
else:
return None
class DauphinRuntimeTypeNotFoundError(dauphin.ObjectType):
class Meta:
name = 'RuntimeTypeNotFoundError'
interfaces = (DauphinError, )
pipeline = dauphin.NonNull('Pipeline')
runtime_type_name = dauphin.NonNull(dauphin.String)
class DauphinOutputDefinition(dauphin.ObjectType):
class Meta:
name = 'OutputDefinition'
solid_definition = dauphin.NonNull('SolidDefinition')
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
type = dauphin.NonNull('RuntimeType')
expectations = dauphin.non_null_list('Expectation')
# outputs - ?
def __init__(self, output_definition, solid_def):
super(DauphinOutputDefinition, self).__init__(
name=output_definition.name,
description=output_definition.description,
solid_definition=solid_def,
)
self._output_definition = check.inst_param(
output_definition, 'output_definition', OutputDefinition
)
def resolve_type(self, _graphene_info):
return to_dauphin_runtime_type(self._output_definition.runtime_type)
def resolve_expectations(self, graphene_info):
if self._output_definition.expectations:
return [
graphene_info.schema.type_named('Expectation')(expectation)
for expectation in self._output_definition.expectations
]
else:
return []
class DauphinSuccessfulStepOutputEvent(dauphin.ObjectType):
class Meta:
name = 'SuccessfulStepOutputEvent'
interfaces = (DauphinStepEvent, )
output_name = dauphin.Field(dauphin.NonNull(dauphin.String))
value_repr = dauphin.Field(dauphin.NonNull(dauphin.String))
class DauphinOutput(dauphin.ObjectType):
class Meta:
name = 'Output'
solid = dauphin.NonNull('Solid')
definition = dauphin.NonNull('OutputDefinition')
depended_by = dauphin.non_null_list('Input')
def __init__(self, output_handle, solid):
super(DauphinOutput, self).__init__(solid=solid)
self._solid = check.inst_param(solid, 'solid', DauphinSolid)
self._output_handle = check.inst_param(output_handle, 'output_handle',
SolidOutputHandle)
def resolve_definition(self, info):
return info.schema.type_named('OutputDefinition')(
self._output_handle.output_def,
self._solid.resolve_definition(info))
def resolve_depended_by(self, info):
return [
info.schema.type_named('Input')(input_handle,
DauphinSolid(input_handle.solid))
for input_handle in self._solid.depended_by.get(
self._output_handle, [])
]
class DauphinStepExecution(dauphin.InputObjectType):
class Meta:
name = 'StepExecution'
stepKey = dauphin.NonNull(dauphin.String)
marshalledInputs = dauphin.List(dauphin.NonNull(DauphinMarshalledInput))
marshalledOutputs = dauphin.List(dauphin.NonNull(DauphinMarshalledOutput))
class DauphinInputDefinition(dauphin.ObjectType):
class Meta:
name = 'InputDefinition'
solid_definition = dauphin.NonNull('SolidDefinition')
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
type = dauphin.NonNull('Type')
expectations = dauphin.non_null_list('Expectation')
# inputs - ?
def __init__(self, input_definition, solid_def):
super(DauphinInputDefinition, self).__init__(
name=input_definition.name,
description=input_definition.description,
solid_definition=solid_def,
)
self._input_definition = check.inst_param(input_definition,
'input_definition',
InputDefinition)
def resolve_type(self, info):
return info.schema.type_named('Type').to_dauphin_type(
info, self._input_definition.runtime_type)
def resolve_expectations(self, info):
if self._input_definition.expectations:
return [
info.schema.type_named('Expectation')(
expectation
for expectation in self._input_definition.expectations)
]
else:
return []
class DauphinStepMaterializationEvent(dauphin.ObjectType):
class Meta:
name = 'StepMaterializationEvent'
interfaces = (DauphinMessageEvent, DauphinExecutionStepEvent)
file_name = dauphin.NonNull(dauphin.String)
file_location = dauphin.NonNull(dauphin.String)
class DauphinMessageEvent(dauphin.Interface):
class Meta:
name = 'MessageEvent'
run = dauphin.NonNull('PipelineRun')
message = dauphin.NonNull(dauphin.String)
timestamp = dauphin.NonNull(dauphin.String)
level = dauphin.NonNull('LogLevel')
class DauphinPageInfo(dauphin.ObjectType):
class Meta:
name = 'PageInfo'
lastCursor = dauphin.Field('Cursor')
hasNextPage = dauphin.Field(dauphin.Boolean)
hasPreviousPage = dauphin.Field(dauphin.Boolean)
count = dauphin.NonNull(dauphin.Int)
totalCount = dauphin.NonNull(dauphin.Int)
class DauphinExecutionSelector(dauphin.InputObjectType):
class Meta:
name = 'ExecutionSelector'
description = '''This type represents the fields necessary to identify a
pipeline or pipeline subset.'''
name = dauphin.NonNull(dauphin.String)
solidSubset = dauphin.List(dauphin.NonNull(dauphin.String))
def to_selector(self):
return ExecutionSelector(self.name, self.solidSubset)
class DauphinPipelineConfigValidationError(dauphin.Interface):
class Meta:
name = 'PipelineConfigValidationError'
message = dauphin.NonNull(dauphin.String)
path = dauphin.non_null_list(dauphin.String)
stack = dauphin.NonNull('EvaluationStack')
reason = dauphin.NonNull('EvaluationErrorReason')
@staticmethod
def from_dagster_error(graphene_info, error):
check.inst_param(error, 'error', EvaluationError)
if isinstance(error.error_data, RuntimeMismatchErrorData):
return graphene_info.schema.type_named(
'RuntimeMismatchConfigError')(
message=error.message,
path=[], # TODO: remove
stack=error.stack,
reason=error.reason,
type=error.error_data.config_type,
value_rep=error.error_data.value_rep,
)
elif isinstance(error.error_data, MissingFieldErrorData):
return graphene_info.schema.type_named('MissingFieldConfigError')(
message=error.message,
path=[], # TODO: remove
stack=error.stack,
reason=error.reason,
field=graphene_info.schema.type_named('ConfigTypeField')(
name=error.error_data.field_name,
field=error.error_data.field_def),
)
elif isinstance(error.error_data, FieldNotDefinedErrorData):
return graphene_info.schema.type_named(
'FieldNotDefinedConfigError')(
message=error.message,
path=[], # TODO: remove
stack=error.stack,
reason=error.reason,
field_name=error.error_data.field_name,
)
elif isinstance(error.error_data, SelectorTypeErrorData):
return graphene_info.schema.type_named('SelectorTypeConfigError')(
message=error.message,
path=[], # TODO: remove
stack=error.stack,
reason=error.reason,
incoming_fields=error.error_data.incoming_fields,
)
else:
check.failed('Error type not supported {error_data}'.format(
error_data=repr(error.error_data)))
class DauphinSubscription(dauphin.ObjectType):
class Meta:
name = 'Subscription'
pipelineRunLogs = dauphin.Field(
dauphin.NonNull('PipelineRunLogsSubscriptionPayload'),
runId=dauphin.Argument(dauphin.NonNull(dauphin.ID)),
after=dauphin.Argument('Cursor'),
)
def resolve_pipelineRunLogs(self, info, runId, after=None):
return model.get_pipeline_run_observable(info, runId, after)
class DauphinStartSubplanExecution(dauphin.Mutation):
class Meta:
name = 'StartSubplanExecution'
class Arguments:
pipelineName = dauphin.NonNull(dauphin.String)
config = dauphin.Argument('PipelineConfig')
stepExecutions = dauphin.non_null_list(DauphinStepExecution)
executionMetadata = dauphin.Argument(dauphin.NonNull(DauphinExecutionMetadata))
Output = dauphin.NonNull('StartSubplanExecutionResult')
def mutate(self, info, **kwargs):
return model.start_subplan_execution(
model.SubplanExecutionArgs(
info,
kwargs['pipelineName'],
kwargs.get('config'),
list(
map(
lambda data: model.StepExecution(
data['stepKey'],
data.get('marshalledInputs', []),
data.get('marshalledOutputs', []),
),
kwargs['stepExecutions'],
)
),
kwargs['executionMetadata'].to_metadata(),
)
)
class DauphinLogMessageConnection(dauphin.ObjectType):
class Meta:
name = 'LogMessageConnection'
nodes = dauphin.non_null_list('PipelineRunEvent')
pageInfo = dauphin.NonNull('PageInfo')
def __init__(self, pipeline_run):
self._pipeline_run = check.inst_param(
pipeline_run, 'pipeline_run', pipeline_run_storage.PipelineRun
)
self._logs = self._pipeline_run.all_logs()
def resolve_nodes(self, info):
pipeline = model.get_pipeline_or_raise(info, self._pipeline_run.selector)
return [
info.schema.type_named('PipelineRunEvent').from_dagster_event(info, log, pipeline)
for log in self._logs
]
def resolve_pageInfo(self, info):
count = len(self._logs)
lastCursor = None
if count > 0:
lastCursor = str(count - 1)
return info.schema.type_named('PageInfo')(
lastCursor=lastCursor,
hasNextPage=None,
hasPreviousPage=None,
count=count,
totalCount=count,
)
class DauphinRuntimeType(dauphin.Interface):
class Meta:
name = 'RuntimeType'
key = dauphin.NonNull(dauphin.String)
name = dauphin.String()
display_name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
is_nullable = dauphin.NonNull(dauphin.Boolean)
is_list = dauphin.NonNull(dauphin.Boolean)
is_builtin = dauphin.NonNull(dauphin.Boolean)
input_schema_type = dauphin.Field(DauphinConfigType)
output_schema_type = dauphin.Field(DauphinConfigType)
inner_types = dauphin.non_null_list('RuntimeType')
class DauphinExecutionStepOutput(dauphin.ObjectType):
class Meta:
name = 'ExecutionStepOutput'
name = dauphin.NonNull(dauphin.String)
type = dauphin.Field(dauphin.NonNull('RuntimeType'))
def __init__(self, step_output):
super(DauphinExecutionStepOutput, self).__init__()
self._step_output = check.inst_param(step_output, 'step_output',
StepOutput)
def resolve_name(self, _graphene_info):
return self._step_output.name
def resolve_type(self, _graphene_info):
return to_dauphin_runtime_type(self._step_output.runtime_type)
class DauphinSolid(dauphin.ObjectType):
class Meta:
name = 'Solid'
name = dauphin.NonNull(dauphin.String)
definition = dauphin.NonNull('SolidDefinition')
inputs = dauphin.non_null_list('Input')
outputs = dauphin.non_null_list('Output')
def __init__(self, solid, depends_on=None, depended_by=None):
super(DauphinSolid, self).__init__(name=solid.name)
self._solid = check.inst_param(solid, 'solid', Solid)
if depends_on:
self.depends_on = {
input_handle: output_handle
for input_handle, output_handle in depends_on.items()
}
else:
self.depends_on = {}
if depended_by:
self.depended_by = {
output_handle: input_handles
for output_handle, input_handles in depended_by.items()
}
else:
self.depended_by = {}
def resolve_definition(self, info):
return info.schema.type_named('SolidDefinition')(
self._solid.definition)
def resolve_inputs(self, info):
return [
info.schema.type_named('Input')(input_handle, self)
for input_handle in self._solid.input_handles()
]
def resolve_outputs(self, info):
return [
info.schema.type_named('Output')(output_handle, self)
for output_handle in self._solid.output_handles()
]
class DauphinRuntimeMismatchConfigError(dauphin.ObjectType):
class Meta:
name = 'RuntimeMismatchConfigError'
interfaces = (DauphinPipelineConfigValidationError, )
type = dauphin.NonNull('ConfigType')
value_rep = dauphin.Field(dauphin.String)
def resolve_type(self, _info):
return to_dauphin_config_type(self.type)
class DauphinExecutionStep(dauphin.ObjectType):
class Meta:
name = 'ExecutionStep'
name = dauphin.Field(dauphin.NonNull(dauphin.String),
deprecation_reason='Use key')
key = dauphin.NonNull(dauphin.String)
inputs = dauphin.non_null_list('ExecutionStepInput')
outputs = dauphin.non_null_list('ExecutionStepOutput')
solid = dauphin.NonNull('Solid')
kind = dauphin.NonNull('StepKind')
def __init__(self, execution_step):
super(DauphinExecutionStep, self).__init__()
self.execution_step = check.inst_param(execution_step,
'execution_step', ExecutionStep)
def resolve_inputs(self, graphene_info):
return [
graphene_info.schema.type_named('ExecutionStepInput')(inp)
for inp in self.execution_step.step_inputs
]
def resolve_outputs(self, graphene_info):
return [
graphene_info.schema.type_named('ExecutionStepOutput')(out)
for out in self.execution_step.step_outputs
]
def resolve_key(self, _graphene_info):
return self.execution_step.key
def resolve_name(self, _graphene_info):
return self.execution_step.key
def resolve_solid(self, graphene_info):
return graphene_info.schema.type_named('Solid')(
self.execution_step.solid)
def resolve_kind(self, _graphene_info):
return self.execution_step.kind
class DauphinEvaluationStackListItemEntry(dauphin.ObjectType):
class Meta:
name = 'EvaluationStackListItemEntry'
def __init__(self, list_index):
super(DauphinEvaluationStackListItemEntry, self).__init__()
self._list_index = list_index
list_index = dauphin.NonNull(dauphin.Int)
def resolve_list_index(self, _info):
return self._list_index
class DauphinExpectation(dauphin.ObjectType):
class Meta:
name = 'Expectation'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
def __init__(self, expectation):
check.inst_param(expectation, 'expectation', ExpectationDefinition)
super(DauphinExpectation, self).__init__(
name=expectation.name, description=expectation.description
)
class DauphinSolidNotFoundError(dauphin.ObjectType):
class Meta:
name = 'SolidNotFoundError'
interfaces = (DauphinError, )
solid_name = dauphin.NonNull(dauphin.String)
def __init__(self, solid_name):
super(DauphinSolidNotFoundError, self).__init__()
self.solid_name = check.str_param(solid_name, 'solid_name')
self.message = 'Solid {solid_name} does not exist'.format(
solid_name=solid_name)
class DauphinPipelineNotFoundError(dauphin.ObjectType):
class Meta:
name = 'PipelineNotFoundError'
interfaces = (DauphinError, )
pipeline_name = dauphin.NonNull(dauphin.String)
def __init__(self, pipeline_name):
super(DauphinPipelineNotFoundError, self).__init__()
self.pipeline_name = check.str_param(pipeline_name, 'pipeline_name')
self.message = 'Pipeline {pipeline_name} does not exist'.format(
pipeline_name=pipeline_name)
class DauphinConfigTypeField(dauphin.ObjectType):
class Meta:
name = 'ConfigTypeField'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
config_type = dauphin.NonNull('ConfigType')
default_value = dauphin.String()
is_optional = dauphin.NonNull(dauphin.Boolean)
def __init__(self, name, field):
super(DauphinConfigTypeField, self).__init__(
name=name,
description=field.description,
default_value=field.default_value_as_str if field.default_provided else None,
is_optional=field.is_optional,
)
self._field = field
def resolve_config_type(self, _info):
return to_dauphin_config_type(self._field.config_type)
