class DauphinRunGroup(dauphin.ObjectType):
class Meta(object):
name = 'RunGroup'
rootRunId = dauphin.NonNull(dauphin.String)
runs = dauphin.List(DauphinPipelineRun)
def __init__(self, root_run_id, runs):
check.str_param(root_run_id, 'root_run_id')
check.list_param(runs, 'runs', DauphinPipelineRun)
super(DauphinRunGroup, self).__init__(rootRunId=root_run_id, runs=runs)
class DauphinScheduleDefinition(dauphin.ObjectType):
class Meta(object):
name = 'ScheduleDefinition'
name = dauphin.NonNull(dauphin.String)
cron_schedule = dauphin.NonNull(dauphin.String)
pipeline_name = dauphin.NonNull(dauphin.String)
solid_subset = dauphin.List(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
run_config_yaml = dauphin.Field(dauphin.String)
partition_set = dauphin.Field('PartitionSet')
def resolve_run_config_yaml(self, _graphene_info):
schedule_def = self._schedule_def
try:
with user_code_error_boundary(
ScheduleExecutionError,
lambda:
'Error occurred during the execution of environment_dict_fn for schedule '
'{schedule_name}'.format(schedule_name=schedule_def.name),
):
environment_config = schedule_def.get_environment_dict(
self._schedule_context)
except ScheduleExecutionError:
return None
run_config_yaml = yaml.dump(environment_config,
default_flow_style=False)
return run_config_yaml if run_config_yaml else ''
def resolve_partition_set(self, graphene_info):
if isinstance(self._schedule_def, PartitionScheduleDefinition):
return graphene_info.schema.type_named('PartitionSet')(
self._schedule_def.get_partition_set())
return None
def __init__(self, graphene_info, schedule_def):
self._schedule_def = check.inst_param(schedule_def, 'schedule_def',
ScheduleDefinition)
self._schedule_context = ScheduleExecutionContext(
graphene_info.context.instance)
self._schedule_def = check.inst_param(schedule_def, 'schedule_def',
ScheduleDefinition)
super(DauphinScheduleDefinition, self).__init__(
name=schedule_def.name,
cron_schedule=schedule_def.cron_schedule,
pipeline_name=schedule_def.pipeline_name,
solid_subset=schedule_def.solid_subset,
mode=schedule_def.mode,
)
class DauphinAsset(dauphin.ObjectType):
class Meta:
name = "Asset"
key = dauphin.NonNull("AssetKey")
assetMaterializations = dauphin.Field(
dauphin.non_null_list("AssetMaterialization"),
partitions=dauphin.List(dauphin.String),
cursor=dauphin.String(),
limit=dauphin.Int(),
)
runs = dauphin.Field(
dauphin.non_null_list("PipelineRun"), cursor=dauphin.String(), limit=dauphin.Int(),
)
def resolve_assetMaterializations(self, graphene_info, **kwargs):
return [
graphene_info.schema.type_named("AssetMaterialization")(event=event)
for event in get_asset_events(
graphene_info,
self.key,
kwargs.get("partitions"),
kwargs.get("cursor"),
kwargs.get("limit"),
)
]
def resolve_runs(self, graphene_info, **kwargs):
cursor = kwargs.get("cursor")
limit = kwargs.get("limit")
run_ids = get_asset_run_ids(graphene_info, self.key)
if not run_ids:
return []
# for now, handle cursor/limit here instead of in the DB layer
if cursor:
try:
idx = run_ids.index(cursor)
run_ids = run_ids[idx:]
except ValueError:
return []
if limit:
run_ids = run_ids[:limit]
return [
graphene_info.schema.type_named("PipelineRun")(r)
for r in graphene_info.context.instance.get_runs(
filters=PipelineRunsFilter(run_ids=run_ids)
)
]
class DauphinPartition(dauphin.ObjectType):
class Meta(object):
name = 'Partition'
name = dauphin.NonNull(dauphin.String)
partition_set_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
runConfigOrError = dauphin.NonNull('PartitionRunConfigOrError')
tagsOrError = dauphin.NonNull('PartitionTagsOrError')
runs = dauphin.non_null_list('PipelineRun')
def __init__(self, external_repository_handle, external_partition_set, partition_name):
self._external_repository_handle = check.inst_param(
external_repository_handle, 'external_respository_handle', RepositoryHandle
)
self._external_partition_set = check.inst_param(
external_partition_set, 'external_partition_set', ExternalPartitionSet
)
self._partition_name = check.str_param(partition_name, 'partition_name')
super(DauphinPartition, self).__init__(
name=partition_name,
partition_set_name=external_partition_set.name,
solid_selection=external_partition_set.solid_selection,
mode=external_partition_set.mode,
)
def resolve_runConfigOrError(self, graphene_info):
return get_partition_config(
graphene_info,
self._external_repository_handle,
self._external_partition_set.name,
self._partition_name,
)
def resolve_tagsOrError(self, graphene_info):
return get_partition_tags(
graphene_info,
self._external_repository_handle,
self._external_partition_set.name,
self._partition_name,
)
def resolve_runs(self, graphene_info):
runs_filter = PipelineRunsFilter(
tags={
'dagster/partition_set': self._external_partition_set.name,
'dagster/partition': self._partition_name,
}
)
return get_runs(graphene_info, runs_filter)
class DauphinSensor(dauphin.ObjectType):
class Meta:
name = "Sensor"
id = dauphin.NonNull(dauphin.ID)
jobOriginId = dauphin.NonNull(dauphin.String)
name = dauphin.NonNull(dauphin.String)
pipelineName = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
sensorState = dauphin.NonNull("JobState")
nextTick = dauphin.Field("FutureJobTick")
def resolve_id(self, _):
return "%s:%s" % (self.name, self.pipelineName)
def __init__(self, graphene_info, external_sensor):
self._external_sensor = check.inst_param(external_sensor,
"external_sensor",
ExternalSensor)
self._sensor_state = graphene_info.context.instance.get_job_state(
self._external_sensor.get_external_origin_id())
if not self._sensor_state:
# Also include a SensorState for a stopped sensor that may not
# have a stored database row yet
self._sensor_state = self._external_sensor.get_default_job_state()
super(DauphinSensor, self).__init__(
name=external_sensor.name,
jobOriginId=external_sensor.get_external_origin_id(),
pipelineName=external_sensor.pipeline_name,
solidSelection=external_sensor.solid_selection,
mode=external_sensor.mode,
)
def resolve_sensorState(self, graphene_info):
return graphene_info.schema.type_named("JobState")(self._sensor_state)
def resolve_nextTick(self, graphene_info):
if self._sensor_state.status != JobStatus.RUNNING:
return None
latest_tick = graphene_info.context.instance.get_latest_job_tick(
self._sensor_state.job_origin_id)
if not latest_tick:
return None
next_timestamp = latest_tick.timestamp + SENSOR_DAEMON_INTERVAL
if next_timestamp < datetime_as_float(datetime.now()):
return None
return graphene_info.schema.type_named("FutureJobTick")(next_timestamp)
class DauphinPartition(dauphin.ObjectType):
class Meta(object):
name = 'Partition'
name = dauphin.NonNull(dauphin.String)
partition_set_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
runConfigYaml = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list('PipelineTag')
runs = dauphin.non_null_list('PipelineRun')
def __init__(self, partition_name, partition_set_def,
external_partition_set):
self._partition_name = check.str_param(partition_name,
'partition_name')
self._partition_set_def = check.inst_param(partition_set_def,
'partition_set_def',
PartitionSetDefinition)
self._external_partition_set = check.inst_param(
external_partition_set, 'external_partition_set',
ExternalPartitionSet)
super(DauphinPartition, self).__init__(
name=partition_name,
partition_set_name=external_partition_set.name,
solid_selection=external_partition_set.solid_selection,
mode=external_partition_set.mode,
)
def resolve_runConfigYaml(self, _):
partition = self._partition_set_def.get_partition(self._partition_name)
environment_dict = self._partition_set_def.environment_dict_for_partition(
partition)
return yaml.dump(environment_dict, default_flow_style=False)
def resolve_tags(self, graphene_info):
partition = self._partition_set_def.get_partition(self._partition_name)
tags = self._partition_set_def.tags_for_partition(partition).items()
return [
graphene_info.schema.type_named('PipelineTag')(key=key,
value=value)
for key, value in tags
]
def resolve_runs(self, graphene_info):
runs_filter = PipelineRunsFilter(
tags={
'dagster/partition_set': self._external_partition_set.name,
'dagster/partition': self._partition_name,
})
return get_runs(graphene_info, runs_filter)
class DauphinPipelineSelector(dauphin.InputObjectType):
class Meta(object):
name = 'PipelineSelector'
description = '''This type represents the fields necessary to identify a
pipeline or pipeline subset.'''
# legacy_
name = dauphin.Field(dauphin.String)
pipelineName = dauphin.Field(dauphin.String)
repositoryName = dauphin.Field(dauphin.String)
repositoryLocationName = dauphin.Field(dauphin.String)
solidSubset = dauphin.List(dauphin.NonNull(dauphin.String))
class DauphinScheduleDefinition(dauphin.ObjectType):
class Meta(object):
name = "ScheduleDefinition"
name = dauphin.NonNull(dauphin.String)
cron_schedule = dauphin.NonNull(dauphin.String)
pipeline_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
execution_timezone = dauphin.Field(dauphin.String)
schedule_state = dauphin.Field("ScheduleState")
runConfigOrError = dauphin.Field("ScheduleRunConfigOrError")
partition_set = dauphin.Field("PartitionSet")
def resolve_runConfigOrError(self, graphene_info):
return get_schedule_config(graphene_info, self._external_schedule)
def resolve_partition_set(self, graphene_info):
if self._external_schedule.partition_set_name is None:
return None
repository = graphene_info.context.get_repository_location(
self._external_schedule.handle.location_name).get_repository(
self._external_schedule.handle.repository_name)
external_partition_set = repository.get_external_partition_set(
self._external_schedule.partition_set_name)
return graphene_info.schema.type_named("PartitionSet")(
external_repository_handle=repository.handle,
external_partition_set=external_partition_set,
)
def __init__(self, graphene_info, external_schedule):
self._external_schedule = check.inst_param(external_schedule,
"external_schedule",
ExternalSchedule)
self._schedule_state = graphene_info.context.instance.get_schedule_state(
self._external_schedule.get_origin_id())
super(DauphinScheduleDefinition, self).__init__(
name=external_schedule.name,
cron_schedule=external_schedule.cron_schedule,
pipeline_name=external_schedule.pipeline_name,
solid_selection=external_schedule.solid_selection,
mode=external_schedule.mode,
schedule_state=graphene_info.schema.type_named("ScheduleState")(
graphene_info, self._schedule_state)
if self._schedule_state else None,
execution_timezone=self._external_schedule.execution_timezone,
)
class DauphinPartitionSet(dauphin.ObjectType):
class Meta(object):
name = 'PartitionSet'
name = dauphin.NonNull(dauphin.String)
pipeline_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
partitions = dauphin.Field(
dauphin.NonNull('Partitions'),
cursor=dauphin.String(),
limit=dauphin.Int(),
reverse=dauphin.Boolean(),
)
partition = dauphin.Field('Partition',
partition_name=dauphin.NonNull(dauphin.String))
def __init__(self, external_repository_handle, external_partition_set):
self._external_repository_handle = check.inst_param(
external_repository_handle, 'external_respository_handle',
RepositoryHandle)
self._external_partition_set = check.inst_param(
external_partition_set, 'external_partition_set',
ExternalPartitionSet)
super(DauphinPartitionSet, self).__init__(
name=external_partition_set.name,
pipeline_name=external_partition_set.pipeline_name,
solid_selection=external_partition_set.solid_selection,
mode=external_partition_set.mode,
)
def resolve_partitions(self, graphene_info, **kwargs):
return get_partitions(
graphene_info,
self._external_repository_handle,
self._external_partition_set,
cursor=kwargs.get("cursor"),
limit=kwargs.get("limit"),
reverse=kwargs.get('reverse'),
)
def resolve_partition(self, graphene_info, partition_name):
return get_partition_by_name(
graphene_info,
self._external_repository_handle,
self._external_partition_set,
partition_name,
)
class DauphinExecutionMetadata(dauphin.InputObjectType):
class Meta(object):
name = "ExecutionMetadata"
runId = dauphin.String()
tags = dauphin.List(dauphin.NonNull(DauphinExecutionTag))
rootRunId = dauphin.String(
description="""The ID of the run at the root of the run group. All partial /
full re-executions should use the first run as the rootRunID so they are
grouped together."""
)
parentRunId = dauphin.String(
description="""The ID of the run serving as the parent within the run group.
For the first re-execution, this will be the same as the `rootRunId`. For
subsequent runs, the root or a previous re-execution could be the parent run."""
)
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')
stepKeysToExecute = dauphin.List(dauphin.String)
environmentConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
def __init__(self, pipeline_run):
super(DauphinPipelineRun, self).__init__(runId=pipeline_run.run_id,
status=pipeline_run.status,
mode=pipeline_run.mode)
self._pipeline_run = check.inst_param(pipeline_run, 'pipeline_run',
PipelineRun)
def resolve_pipeline(self, graphene_info):
return get_pipeline_or_raise(graphene_info,
self._pipeline_run.selector)
def resolve_logs(self, graphene_info):
return graphene_info.schema.type_named('LogMessageConnection')(
self._pipeline_run)
def resolve_executionPlan(self, graphene_info):
pipeline = self.resolve_pipeline(graphene_info)
execution_plan = create_execution_plan(
pipeline.get_dagster_pipeline(),
self._pipeline_run.config,
RunConfig(mode=self._pipeline_run.mode),
)
return graphene_info.schema.type_named('ExecutionPlan')(pipeline,
execution_plan)
def resolve_stepKeysToExecute(self, _):
return self._pipeline_run.step_keys_to_execute
def resolve_environmentConfigYaml(self, _graphene_info):
return yaml.dump(self._pipeline_run.config, default_flow_style=False)
@property
def run_id(self):
return self.runId
class DauphinPartitionSet(dauphin.ObjectType):
class Meta(object):
name = 'PartitionSet'
name = dauphin.NonNull(dauphin.String)
pipeline_name = dauphin.NonNull(dauphin.String)
solid_subset = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
partitions = dauphin.Field(
dauphin.NonNull('Partitions'),
cursor=dauphin.String(),
limit=dauphin.Int(),
)
def __init__(self, partition_set):
self._partition_set = check.inst_param(partition_set, 'partition_set',
PartitionSetDefinition)
super(DauphinPartitionSet, self).__init__(
name=partition_set.name,
pipeline_name=partition_set.pipeline_name,
solid_subset=partition_set.solid_subset,
mode=partition_set.mode,
)
def resolve_partitions(self, graphene_info, **kwargs):
partitions = self._partition_set.get_partitions()
cursor = kwargs.get("cursor")
limit = kwargs.get("limit")
if cursor and limit:
index = next(
(idx for (idx, partition) in enumerate(partitions)
if partition.name == cursor),
None,
)
partitions = partitions[index:min(len(partitions), index + limit)]
elif limit:
partitions = partitions[:min(len(partitions), limit)]
return graphene_info.schema.type_named('Partitions')(results=[
graphene_info.schema.type_named('Partition')(
partition=partition, partition_set=self._partition_set)
for partition in partitions
])
class DauphinPipelinePreset(dauphin.ObjectType):
class Meta:
name = 'PipelinePreset'
name = dauphin.NonNull(dauphin.String)
solidSubset = dauphin.List(dauphin.NonNull(dauphin.String))
environment = dauphin.String()
def __init__(self, preset):
self.preset = check.inst_param(preset, 'preset', PipelinePreset)
def resolve_name(self, _graphene_info):
return self.preset.name
def resolve_solidSubset(self, _graphene_info):
return self.preset.solid_subset
def resolve_environment(self, _graphene_info):
return self.preset.environment_yaml
class DauphinSensor(dauphin.ObjectType):
class Meta:
name = "Sensor"
id = dauphin.NonNull(dauphin.ID)
jobOriginId = dauphin.NonNull(dauphin.String)
name = dauphin.NonNull(dauphin.String)
pipelineName = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
sensorState = dauphin.NonNull("JobState")
nextTick = dauphin.Field("FutureJobTick")
def resolve_id(self, _):
return "%s:%s" % (self.name, self.pipelineName)
def __init__(self, graphene_info, external_sensor):
self._external_sensor = check.inst_param(external_sensor, "external_sensor", ExternalSensor)
self._sensor_state = graphene_info.context.instance.get_job_state(
self._external_sensor.get_external_origin_id()
)
if not self._sensor_state:
# Also include a SensorState for a stopped sensor that may not
# have a stored database row yet
self._sensor_state = self._external_sensor.get_default_job_state(
graphene_info.context.instance
)
super(DauphinSensor, self).__init__(
name=external_sensor.name,
jobOriginId=external_sensor.get_external_origin_id(),
pipelineName=external_sensor.pipeline_name,
solidSelection=external_sensor.solid_selection,
mode=external_sensor.mode,
)
def resolve_sensorState(self, graphene_info):
return graphene_info.schema.type_named("JobState")(self._sensor_state)
def resolve_nextTick(self, graphene_info):
return get_sensor_next_tick(graphene_info, self._sensor_state)
class DauphinPipelinePreset(dauphin.ObjectType):
class Meta:
name = "PipelinePreset"
name = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.NonNull(dauphin.String))
runConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list("PipelineTag")
def __init__(self, active_preset_data, pipeline_name):
self._active_preset_data = check.inst_param(active_preset_data,
"active_preset_data",
ExternalPresetData)
self._pipeline_name = check.str_param(pipeline_name, "pipeline_name")
def resolve_name(self, _graphene_info):
return self._active_preset_data.name
def resolve_solidSelection(self, _graphene_info):
return self._active_preset_data.solid_selection
def resolve_runConfigYaml(self, _graphene_info):
yaml_str = yaml.safe_dump(self._active_preset_data.run_config,
default_flow_style=False,
allow_unicode=True)
return yaml_str if yaml_str else ""
def resolve_mode(self, _graphene_info):
return self._active_preset_data.mode
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named("PipelineTag")(key=key,
value=value)
for key, value in self._active_preset_data.tags.items()
if get_tag_type(key) != TagType.HIDDEN
]
class DauphinPipelinePreset(dauphin.ObjectType):
class Meta:
name = 'PipelinePreset'
name = dauphin.NonNull(dauphin.String)
solidSubset = dauphin.List(dauphin.NonNull(dauphin.String))
environmentConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
def __init__(self, preset):
self._preset = check.inst_param(preset, 'preset', PresetDefinition)
def resolve_name(self, _graphene_info):
return self._preset.name
def resolve_solidSubset(self, _graphene_info):
return self._preset.solid_subset
def resolve_environmentConfigYaml(self, _graphene_info):
return self._preset.environment_yaml if self._preset.environment_yaml else ''
def resolve_mode(self, _graphene_info):
return self._preset.mode
class DauphinPartition(dauphin.ObjectType):
class Meta(object):
name = 'Partition'
name = dauphin.NonNull(dauphin.String)
partition_set_name = dauphin.NonNull(dauphin.String)
solid_subset = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
environmentConfigYaml = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list('PipelineTag')
def __init__(self, partition, partition_set):
self._partition = check.inst_param(partition, 'partition', Partition)
self._partition_set = check.inst_param(partition_set, 'partition_set',
PartitionSetDefinition)
super(DauphinPartition, self).__init__(
name=partition.name,
partition_set_name=partition_set.name,
solid_subset=partition_set.solid_subset,
mode=partition_set.mode,
)
def resolve_environmentConfigYaml(self, _):
environment_dict = self._partition_set.environment_dict_for_partition(
self._partition)
return yaml.dump(environment_dict, default_flow_style=False)
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineTag')(key=key,
value=value)
for key, value in self._partition_set.tags_for_partition(
self._partition).items()
]
class DauphinPipelinePreset(dauphin.ObjectType):
class Meta(object):
name = 'PipelinePreset'
name = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.NonNull(dauphin.String))
runConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list('PipelineTag')
def __init__(self, active_preset_data, pipeline_name):
self._active_preset_data = check.inst_param(active_preset_data,
'active_preset_data',
ExternalPresetData)
self._pipeline_name = check.str_param(pipeline_name, 'pipeline_name')
def resolve_name(self, _graphene_info):
return self._active_preset_data.name
def resolve_solidSelection(self, _graphene_info):
return self._active_preset_data.solid_selection
def resolve_runConfigYaml(self, _graphene_info):
yaml_str = yaml.safe_dump(self._active_preset_data.run_config,
default_flow_style=False)
return yaml_str if yaml_str else ''
def resolve_mode(self, _graphene_info):
return self._active_preset_data.mode
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineTag')(key=key,
value=value)
for key, value in self._active_preset_data.tags.items()
]
class DauphinPipelineRun(dauphin.ObjectType):
class Meta(object):
name = 'PipelineRun'
runId = dauphin.NonNull(dauphin.String)
# Nullable because of historical runs
pipelineSnapshotId = dauphin.String()
status = dauphin.NonNull('PipelineRunStatus')
pipeline = dauphin.NonNull('PipelineReference')
stats = dauphin.NonNull('PipelineRunStatsOrError')
stepStats = dauphin.non_null_list('PipelineRunStepStats')
logs = dauphin.NonNull('LogMessageConnection')
computeLogs = dauphin.Field(
dauphin.NonNull('ComputeLogs'),
stepKey=dauphin.Argument(dauphin.NonNull(dauphin.String)),
description='''
Compute logs are the stdout/stderr logs for a given solid step computation
''',
)
executionPlan = dauphin.Field('ExecutionPlan')
stepKeysToExecute = dauphin.List(dauphin.NonNull(dauphin.String))
environmentConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list('PipelineTag')
rootRunId = dauphin.Field(dauphin.String)
parentRunId = dauphin.Field(dauphin.String)
canCancel = dauphin.NonNull(dauphin.Boolean)
executionSelection = dauphin.NonNull('ExecutionSelection')
def __init__(self, pipeline_run):
super(DauphinPipelineRun, self).__init__(runId=pipeline_run.run_id,
status=pipeline_run.status,
mode=pipeline_run.mode)
self._pipeline_run = check.inst_param(pipeline_run, 'pipeline_run',
PipelineRun)
def resolve_pipeline(self, graphene_info):
return get_pipeline_reference_or_raise(graphene_info,
self._pipeline_run.selector)
def resolve_pipelineSnapshotId(self, _):
return self._pipeline_run.pipeline_snapshot_id
def resolve_logs(self, graphene_info):
return graphene_info.schema.type_named('LogMessageConnection')(
self._pipeline_run)
def resolve_stats(self, graphene_info):
return get_stats(graphene_info, self.run_id)
def resolve_stepStats(self, graphene_info):
return get_step_stats(graphene_info, self.run_id)
def resolve_computeLogs(self, graphene_info, stepKey):
return graphene_info.schema.type_named('ComputeLogs')(
runId=self.run_id, stepKey=stepKey)
def resolve_executionPlan(self, graphene_info):
pipeline = self.resolve_pipeline(graphene_info)
if isinstance(pipeline, DauphinPipeline):
selector = self._pipeline_run.selector
environment_dict = self._pipeline_run.environment_dict
mode = self._pipeline_run.mode
pipeline_def = get_pipeline_def_from_selector(
graphene_info, selector)
if is_config_valid(pipeline_def, environment_dict, mode):
return get_execution_plan(graphene_info, selector,
environment_dict, mode)
return None
def resolve_stepKeysToExecute(self, _):
return self._pipeline_run.step_keys_to_execute
def resolve_environmentConfigYaml(self, _graphene_info):
return yaml.dump(self._pipeline_run.environment_dict,
default_flow_style=False)
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineTag')(key=key,
value=value)
for key, value in self._pipeline_run.tags.items()
]
def resolve_rootRunId(self, _):
return self._pipeline_run.root_run_id
def resolve_parentRunId(self, _):
return self._pipeline_run.parent_run_id
@property
def run_id(self):
return self.runId
def resolve_canCancel(self, graphene_info):
return graphene_info.context.execution_manager.can_terminate(
self.run_id)
def resolve_executionSelection(self, graphene_info):
return graphene_info.schema.type_named('ExecutionSelection')(
self._pipeline_run.selector)
class DauphinPipelineRun(dauphin.ObjectType):
class Meta(object):
name = 'PipelineRun'
runId = dauphin.NonNull(dauphin.String)
# Nullable because of historical runs
pipelineSnapshotId = dauphin.String()
status = dauphin.NonNull('PipelineRunStatus')
pipeline = dauphin.NonNull('PipelineReference')
pipelineName = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.NonNull(dauphin.String))
stats = dauphin.NonNull('PipelineRunStatsOrError')
stepStats = dauphin.non_null_list('PipelineRunStepStats')
computeLogs = dauphin.Field(
dauphin.NonNull('ComputeLogs'),
stepKey=dauphin.Argument(dauphin.NonNull(dauphin.String)),
description='''
Compute logs are the stdout/stderr logs for a given solid step computation
''',
)
executionPlan = dauphin.Field('ExecutionPlan')
stepKeysToExecute = dauphin.List(dauphin.NonNull(dauphin.String))
runConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list('PipelineTag')
rootRunId = dauphin.Field(dauphin.String)
parentRunId = dauphin.Field(dauphin.String)
canTerminate = dauphin.NonNull(dauphin.Boolean)
assets = dauphin.non_null_list('Asset')
def __init__(self, pipeline_run):
super(DauphinPipelineRun, self).__init__(
runId=pipeline_run.run_id, status=pipeline_run.status, mode=pipeline_run.mode
)
self._pipeline_run = check.inst_param(pipeline_run, 'pipeline_run', PipelineRun)
def resolve_pipeline(self, graphene_info):
return get_pipeline_reference_or_raise(graphene_info, self._pipeline_run,)
def resolve_pipelineName(self, _graphene_info):
return self._pipeline_run.pipeline_name
def resolve_solidSelection(self, _graphene_info):
return self._pipeline_run.solid_selection
def resolve_pipelineSnapshotId(self, _):
return self._pipeline_run.pipeline_snapshot_id
def resolve_stats(self, graphene_info):
return get_stats(graphene_info, self.run_id)
def resolve_stepStats(self, graphene_info):
return get_step_stats(graphene_info, self.run_id)
def resolve_computeLogs(self, graphene_info, stepKey):
return graphene_info.schema.type_named('ComputeLogs')(runId=self.run_id, stepKey=stepKey)
def resolve_executionPlan(self, graphene_info):
if not (
self._pipeline_run.execution_plan_snapshot_id
and self._pipeline_run.pipeline_snapshot_id
):
return None
from .execution import DauphinExecutionPlan
instance = graphene_info.context.instance
historical_pipeline = instance.get_historical_pipeline(
self._pipeline_run.pipeline_snapshot_id
)
execution_plan_snapshot = instance.get_execution_plan_snapshot(
self._pipeline_run.execution_plan_snapshot_id
)
return (
DauphinExecutionPlan(
ExternalExecutionPlan(
execution_plan_snapshot=execution_plan_snapshot,
represented_pipeline=historical_pipeline,
)
)
if execution_plan_snapshot and historical_pipeline
else None
)
def resolve_stepKeysToExecute(self, _):
return self._pipeline_run.step_keys_to_execute
def resolve_runConfigYaml(self, _graphene_info):
return yaml.dump(self._pipeline_run.environment_dict, default_flow_style=False)
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineTag')(key=key, value=value)
for key, value in self._pipeline_run.tags.items()
]
def resolve_rootRunId(self, _):
return self._pipeline_run.root_run_id
def resolve_parentRunId(self, _):
return self._pipeline_run.parent_run_id
@property
def run_id(self):
return self.runId
def resolve_canTerminate(self, graphene_info):
return graphene_info.context.instance.run_launcher.can_terminate(self.run_id)
def resolve_assets(self, graphene_info):
return get_assets_for_run_id(graphene_info, self.run_id)
class DauphinPartitionSet(dauphin.ObjectType):
class Meta(object):
name = 'PartitionSet'
name = dauphin.NonNull(dauphin.String)
pipeline_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
partitions = dauphin.Field(
dauphin.NonNull('Partitions'),
cursor=dauphin.String(),
limit=dauphin.Int(),
reverse=dauphin.Boolean(),
)
def __init__(self, partition_set_def, external_partition_set):
self._partition_set_def = check.inst_param(partition_set_def,
'partition_set_def',
PartitionSetDefinition)
self._external_partition_set = check.inst_param(
external_partition_set, 'external_partition_set',
ExternalPartitionSet)
super(DauphinPartitionSet, self).__init__(
name=external_partition_set.name,
pipeline_name=external_partition_set.pipeline_name,
solid_selection=external_partition_set.solid_selection,
mode=external_partition_set.mode,
)
def resolve_partitions(self, graphene_info, **kwargs):
partition_names = self._external_partition_set.partition_names
cursor = kwargs.get("cursor")
limit = kwargs.get("limit")
reverse = kwargs.get('reverse')
start = 0
end = len(partition_names)
index = 0
if cursor:
index = next(
(idx for (idx, partition_name) in enumerate(partition_names)
if partition_name == cursor),
None,
)
if reverse:
end = index
else:
start = index + 1
if limit:
if reverse:
start = end - limit
else:
end = start + limit
partition_names = partition_names[start:end]
return graphene_info.schema.type_named('Partitions')(results=[
graphene_info.schema.type_named('Partition')(
partition_name=partition_name,
partition_set_def=self._partition_set_def,
external_partition_set=self._external_partition_set,
) for partition_name in partition_names
])
class DauphinQuery(dauphin.ObjectType):
class Meta(object):
name = "Query"
version = dauphin.NonNull(dauphin.String)
repositoriesOrError = dauphin.NonNull("RepositoriesOrError")
repositoryOrError = dauphin.Field(
dauphin.NonNull("RepositoryOrError"),
repositorySelector=dauphin.NonNull("RepositorySelector"),
)
pipelineOrError = dauphin.Field(dauphin.NonNull("PipelineOrError"),
params=dauphin.NonNull("PipelineSelector"))
pipelineSnapshotOrError = dauphin.Field(
dauphin.NonNull("PipelineSnapshotOrError"),
snapshotId=dauphin.String(),
activePipelineSelector=dauphin.Argument("PipelineSelector"),
)
scheduler = dauphin.Field(dauphin.NonNull("SchedulerOrError"))
scheduleDefinitionOrError = dauphin.Field(
dauphin.NonNull("ScheduleDefinitionOrError"),
schedule_selector=dauphin.NonNull("ScheduleSelector"),
)
scheduleDefinitionsOrError = dauphin.Field(
dauphin.NonNull("ScheduleDefinitionsOrError"),
repositorySelector=dauphin.NonNull("RepositorySelector"),
)
scheduleStatesOrError = dauphin.Field(
dauphin.NonNull("ScheduleStatesOrError"),
repositorySelector=dauphin.Argument("RepositorySelector"),
withNoScheduleDefinition=dauphin.Boolean(),
)
partitionSetsOrError = dauphin.Field(
dauphin.NonNull("PartitionSetsOrError"),
repositorySelector=dauphin.NonNull("RepositorySelector"),
pipelineName=dauphin.NonNull(dauphin.String),
)
partitionSetOrError = dauphin.Field(
dauphin.NonNull("PartitionSetOrError"),
repositorySelector=dauphin.NonNull("RepositorySelector"),
partitionSetName=dauphin.String(),
)
pipelineRunsOrError = dauphin.Field(
dauphin.NonNull("PipelineRunsOrError"),
filter=dauphin.Argument("PipelineRunsFilter"),
cursor=dauphin.String(),
limit=dauphin.Int(),
)
pipelineRunOrError = dauphin.Field(dauphin.NonNull("PipelineRunOrError"),
runId=dauphin.NonNull(dauphin.ID))
pipelineRunTags = dauphin.non_null_list("PipelineTagAndValues")
runGroupOrError = dauphin.Field(dauphin.NonNull("RunGroupOrError"),
runId=dauphin.NonNull(dauphin.ID))
runGroupsOrError = dauphin.Field(
dauphin.NonNull("RunGroupsOrError"),
filter=dauphin.Argument("PipelineRunsFilter"),
cursor=dauphin.String(),
limit=dauphin.Int(),
)
isPipelineConfigValid = dauphin.Field(
dauphin.NonNull("PipelineConfigValidationResult"),
args={
"pipeline": dauphin.Argument(dauphin.NonNull("PipelineSelector")),
"runConfigData": dauphin.Argument("RunConfigData"),
"mode": dauphin.Argument(dauphin.NonNull(dauphin.String)),
},
)
executionPlanOrError = dauphin.Field(
dauphin.NonNull("ExecutionPlanOrError"),
args={
"pipeline": dauphin.Argument(dauphin.NonNull("PipelineSelector")),
"runConfigData": dauphin.Argument("RunConfigData"),
"mode": dauphin.Argument(dauphin.NonNull(dauphin.String)),
},
)
runConfigSchemaOrError = dauphin.Field(
dauphin.NonNull("RunConfigSchemaOrError"),
args={
"selector": dauphin.Argument(dauphin.NonNull("PipelineSelector")),
"mode": dauphin.Argument(dauphin.String),
},
description=
"""Fetch an environment schema given an execution selection and a mode.
See the descripton on RunConfigSchema for more information.""",
)
instance = dauphin.NonNull("Instance")
assetsOrError = dauphin.Field(
dauphin.NonNull("AssetsOrError"),
prefixPath=dauphin.Argument(
dauphin.List(dauphin.NonNull(dauphin.String))),
)
assetOrError = dauphin.Field(
dauphin.NonNull("AssetOrError"),
assetKey=dauphin.Argument(dauphin.NonNull("AssetKeyInput")),
)
def resolve_repositoriesOrError(self, graphene_info):
return fetch_repositories(graphene_info)
def resolve_repositoryOrError(self, graphene_info, **kwargs):
return fetch_repository(
graphene_info,
RepositorySelector.from_graphql_input(
kwargs.get("repositorySelector")),
)
def resolve_pipelineSnapshotOrError(self, graphene_info, **kwargs):
snapshot_id_arg = kwargs.get("snapshotId")
pipeline_selector_arg = kwargs.get("activePipelineSelector")
check.invariant(
not (snapshot_id_arg and pipeline_selector_arg),
"Must only pass one of snapshotId or activePipelineSelector",
)
check.invariant(
snapshot_id_arg or pipeline_selector_arg,
"Must set one of snapshotId or activePipelineSelector",
)
if pipeline_selector_arg:
pipeline_selector = pipeline_selector_from_graphql(
graphene_info.context, kwargs["activePipelineSelector"])
return get_pipeline_snapshot_or_error_from_pipeline_selector(
graphene_info, pipeline_selector)
else:
return get_pipeline_snapshot_or_error_from_snapshot_id(
graphene_info, snapshot_id_arg)
def resolve_version(self, graphene_info):
return graphene_info.context.version
def resolve_scheduler(self, graphene_info):
return get_scheduler_or_error(graphene_info)
def resolve_scheduleDefinitionOrError(self, graphene_info,
schedule_selector):
return get_schedule_definition_or_error(
graphene_info,
ScheduleSelector.from_graphql_input(schedule_selector))
def resolve_scheduleDefinitionsOrError(self, graphene_info, **kwargs):
return get_schedule_definitions_or_error(
graphene_info,
RepositorySelector.from_graphql_input(
kwargs.get("repositorySelector")))
def resolve_scheduleStatesOrError(self, graphene_info, **kwargs):
return get_schedule_states_or_error(
graphene_info,
RepositorySelector.from_graphql_input(kwargs["repositorySelector"])
if kwargs.get("repositorySelector") else None,
kwargs.get("withNoScheduleDefinition"),
)
def resolve_pipelineOrError(self, graphene_info, **kwargs):
return get_pipeline_or_error(
graphene_info,
pipeline_selector_from_graphql(graphene_info.context,
kwargs["params"]),
)
def resolve_pipelineRunsOrError(self, graphene_info, **kwargs):
filters = kwargs.get("filter")
if filters is not None:
filters = filters.to_selector()
return graphene_info.schema.type_named("PipelineRuns")(
results=get_runs(graphene_info, filters, kwargs.get("cursor"),
kwargs.get("limit")))
def resolve_pipelineRunOrError(self, graphene_info, runId):
return get_run_by_id(graphene_info, runId)
def resolve_runGroupsOrError(self, graphene_info, **kwargs):
filters = kwargs.get("filter")
if filters is not None:
filters = filters.to_selector()
return graphene_info.schema.type_named("RunGroupsOrError")(
results=get_run_groups(graphene_info, filters, kwargs.get(
"cursor"), kwargs.get("limit")))
def resolve_partitionSetsOrError(self, graphene_info, **kwargs):
return get_partition_sets_or_error(
graphene_info,
RepositorySelector.from_graphql_input(
kwargs.get("repositorySelector")),
kwargs.get("pipelineName"),
)
def resolve_partitionSetOrError(self, graphene_info, **kwargs):
return get_partition_set(
graphene_info,
RepositorySelector.from_graphql_input(
kwargs.get("repositorySelector")),
kwargs.get("partitionSetName"),
)
def resolve_pipelineRunTags(self, graphene_info):
return get_run_tags(graphene_info)
def resolve_runGroupOrError(self, graphene_info, runId):
return get_run_group(graphene_info, runId)
def resolve_isPipelineConfigValid(self, graphene_info, pipeline, **kwargs):
return validate_pipeline_config(
graphene_info,
pipeline_selector_from_graphql(graphene_info.context, pipeline),
kwargs.get("runConfigData"),
kwargs.get("mode"),
)
def resolve_executionPlanOrError(self, graphene_info, pipeline, **kwargs):
return get_execution_plan(
graphene_info,
pipeline_selector_from_graphql(graphene_info.context, pipeline),
kwargs.get("runConfigData"),
kwargs.get("mode"),
)
def resolve_runConfigSchemaOrError(self, graphene_info, **kwargs):
return resolve_run_config_schema_or_error(
graphene_info,
pipeline_selector_from_graphql(graphene_info.context,
kwargs["selector"]),
kwargs.get("mode"),
)
def resolve_instance(self, graphene_info):
return graphene_info.schema.type_named("Instance")(
graphene_info.context.instance)
def resolve_assetsOrError(self, graphene_info, **kwargs):
return get_assets(graphene_info, kwargs.get("prefixPath"))
def resolve_assetOrError(self, graphene_info, **kwargs):
return get_asset(graphene_info,
AssetKey.from_graphql_input(kwargs["assetKey"]))
class DauphinPartition(dauphin.ObjectType):
class Meta(object):
name = 'Partition'
name = dauphin.NonNull(dauphin.String)
partition_set_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
runConfigYaml = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list('PipelineTag')
runs = dauphin.non_null_list('PipelineRun')
def __init__(self, external_repository_handle, external_partition_set,
partition_name):
self._external_repository_handle = check.inst_param(
external_repository_handle, 'external_respository_handle',
RepositoryHandle)
self._external_partition_set = check.inst_param(
external_partition_set, 'external_partition_set',
ExternalPartitionSet)
self._partition_name = check.str_param(partition_name,
'partition_name')
super(DauphinPartition, self).__init__(
name=partition_name,
partition_set_name=external_partition_set.name,
solid_selection=external_partition_set.solid_selection,
mode=external_partition_set.mode,
)
def resolve_runConfigYaml(self, _):
run_config = get_partition_config(
self._external_repository_handle,
self._external_partition_set.name,
self._partition_name,
)
if run_config is None:
# TODO: surface user-facing error here
# https://github.com/dagster-io/dagster/issues/2576
return ''
return yaml.dump(run_config, default_flow_style=False)
def resolve_tags(self, graphene_info):
tags = get_partition_tags(
self._external_repository_handle,
self._external_partition_set.name,
self._partition_name,
)
if tags is None:
# TODO: surface user-facing error here
# https://github.com/dagster-io/dagster/issues/2576
return []
return [
graphene_info.schema.type_named('PipelineTag')(key=key,
value=value)
for key, value in tags.items()
]
def resolve_runs(self, graphene_info):
runs_filter = PipelineRunsFilter(
tags={
'dagster/partition_set': self._external_partition_set.name,
'dagster/partition': self._partition_name,
})
return get_runs(graphene_info, runs_filter)
class DauphinExecutionMetadata(dauphin.InputObjectType):
class Meta:
name = 'ExecutionMetadata'
runId = dauphin.String()
tags = dauphin.List(dauphin.NonNull(DauphinExecutionTag))
class DauphinPipelineRun(dauphin.ObjectType):
class Meta:
name = "PipelineRun"
id = dauphin.NonNull(dauphin.ID)
runId = dauphin.NonNull(dauphin.String)
# Nullable because of historical runs
pipelineSnapshotId = dauphin.String()
repositoryOrigin = dauphin.Field("RepositoryOrigin")
status = dauphin.NonNull("PipelineRunStatus")
pipeline = dauphin.NonNull("PipelineReference")
pipelineName = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.NonNull(dauphin.String))
stats = dauphin.NonNull("PipelineRunStatsOrError")
stepStats = dauphin.non_null_list("PipelineRunStepStats")
computeLogs = dauphin.Field(
dauphin.NonNull("ComputeLogs"),
stepKey=dauphin.Argument(dauphin.NonNull(dauphin.String)),
description="""
Compute logs are the stdout/stderr logs for a given solid step computation
""",
)
executionPlan = dauphin.Field("ExecutionPlan")
stepKeysToExecute = dauphin.List(dauphin.NonNull(dauphin.String))
runConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
tags = dauphin.non_null_list("PipelineTag")
rootRunId = dauphin.Field(dauphin.String)
parentRunId = dauphin.Field(dauphin.String)
canTerminate = dauphin.NonNull(dauphin.Boolean)
assets = dauphin.non_null_list("Asset")
def __init__(self, pipeline_run):
super(DauphinPipelineRun, self).__init__(runId=pipeline_run.run_id,
status=pipeline_run.status,
mode=pipeline_run.mode)
self._pipeline_run = check.inst_param(pipeline_run, "pipeline_run",
PipelineRun)
def resolve_id(self, _):
return self._pipeline_run.run_id
def resolve_repositoryOrigin(self, graphene_info):
return (graphene_info.schema.type_named("RepositoryOrigin")(
self._pipeline_run.external_pipeline_origin.
external_repository_origin)
if self._pipeline_run.external_pipeline_origin else None)
def resolve_pipeline(self, graphene_info):
return get_pipeline_reference_or_raise(graphene_info,
self._pipeline_run)
def resolve_pipelineName(self, _graphene_info):
return self._pipeline_run.pipeline_name
def resolve_solidSelection(self, _graphene_info):
return self._pipeline_run.solid_selection
def resolve_pipelineSnapshotId(self, _):
return self._pipeline_run.pipeline_snapshot_id
def resolve_stats(self, graphene_info):
return get_stats(graphene_info, self.run_id)
def resolve_stepStats(self, graphene_info):
return get_step_stats(graphene_info, self.run_id)
def resolve_computeLogs(self, graphene_info, stepKey):
return graphene_info.schema.type_named("ComputeLogs")(
runId=self.run_id, stepKey=stepKey)
def resolve_executionPlan(self, graphene_info):
if not (self._pipeline_run.execution_plan_snapshot_id
and self._pipeline_run.pipeline_snapshot_id):
return None
from .execution import DauphinExecutionPlan
instance = graphene_info.context.instance
historical_pipeline = instance.get_historical_pipeline(
self._pipeline_run.pipeline_snapshot_id)
execution_plan_snapshot = instance.get_execution_plan_snapshot(
self._pipeline_run.execution_plan_snapshot_id)
return (DauphinExecutionPlan(
ExternalExecutionPlan(
execution_plan_snapshot=execution_plan_snapshot,
represented_pipeline=historical_pipeline,
)) if execution_plan_snapshot and historical_pipeline else None)
def resolve_stepKeysToExecute(self, _):
return self._pipeline_run.step_keys_to_execute
def resolve_runConfigYaml(self, _graphene_info):
return yaml.dump(self._pipeline_run.run_config,
default_flow_style=False,
allow_unicode=True)
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named("PipelineTag")(key=key,
value=value)
for key, value in self._pipeline_run.tags.items()
if get_tag_type(key) != TagType.HIDDEN
]
def resolve_rootRunId(self, _):
return self._pipeline_run.root_run_id
def resolve_parentRunId(self, _):
return self._pipeline_run.parent_run_id
@property
def run_id(self):
return self.runId
def resolve_canTerminate(self, graphene_info):
# short circuit if the pipeline run is in a terminal state
if self._pipeline_run.is_finished:
return False
return graphene_info.context.instance.run_launcher.can_terminate(
self.run_id)
def resolve_assets(self, graphene_info):
return get_assets_for_run_id(graphene_info, self.run_id)
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')
computeLogs = dauphin.Field(
dauphin.NonNull('ComputeLogs'),
stepKey=dauphin.Argument(dauphin.NonNull(dauphin.String)),
description='''
Compute logs are the stdout/stderr logs for a given solid step computation
''',
)
executionPlan = dauphin.NonNull('ExecutionPlan')
stepKeysToExecute = dauphin.List(dauphin.NonNull(dauphin.String))
environmentConfigYaml = dauphin.NonNull(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
tags = dauphin.List(dauphin.NonNull('PipelineTag'))
def __init__(self, pipeline_run):
super(DauphinPipelineRun, self).__init__(runId=pipeline_run.run_id,
status=pipeline_run.status,
mode=pipeline_run.mode)
self._pipeline_run = check.inst_param(pipeline_run, 'pipeline_run',
PipelineRun)
def resolve_pipeline(self, graphene_info):
return get_pipeline_or_raise(graphene_info,
self._pipeline_run.selector)
def resolve_logs(self, graphene_info):
return graphene_info.schema.type_named('LogMessageConnection')(
self._pipeline_run)
def resolve_computeLogs(self, graphene_info, stepKey):
update = graphene_info.context.instance.compute_log_manager.read_logs(
self.run_id, stepKey)
return from_compute_log_update(graphene_info, self.run_id, stepKey,
update)
def resolve_executionPlan(self, graphene_info):
pipeline = self.resolve_pipeline(graphene_info)
execution_plan = create_execution_plan(
pipeline.get_dagster_pipeline(),
self._pipeline_run.environment_dict,
RunConfig(mode=self._pipeline_run.mode),
)
return graphene_info.schema.type_named('ExecutionPlan')(pipeline,
execution_plan)
def resolve_stepKeysToExecute(self, _):
return self._pipeline_run.step_keys_to_execute
def resolve_environmentConfigYaml(self, _graphene_info):
return yaml.dump(self._pipeline_run.environment_dict,
default_flow_style=False)
def resolve_tags(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineTag')(key=key,
value=value)
for key, value in self._pipeline_run.tags.items()
]
@property
def run_id(self):
return self.runId
class DauphinRetries(dauphin.InputObjectType):
class Meta(object):
name = 'Retries'
mode = dauphin.Field(dauphin.String)
retries_previous_attempts = dauphin.List(DauphinRetriesPreviousAttempts)
class DauphinPartition(dauphin.ObjectType):
class Meta:
name = "Partition"
name = dauphin.NonNull(dauphin.String)
partition_set_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.NonNull(dauphin.String))
mode = dauphin.NonNull(dauphin.String)
runConfigOrError = dauphin.NonNull("PartitionRunConfigOrError")
tagsOrError = dauphin.NonNull("PartitionTagsOrError")
runs = dauphin.Field(
dauphin.non_null_list("PipelineRun"),
filter=dauphin.Argument("PipelineRunsFilter"),
cursor=dauphin.String(),
limit=dauphin.Int(),
)
status = dauphin.Field("PipelineRunStatus")
def __init__(self, external_repository_handle, external_partition_set,
partition_name):
self._external_repository_handle = check.inst_param(
external_repository_handle, "external_respository_handle",
RepositoryHandle)
self._external_partition_set = check.inst_param(
external_partition_set, "external_partition_set",
ExternalPartitionSet)
self._partition_name = check.str_param(partition_name,
"partition_name")
super(DauphinPartition, self).__init__(
name=partition_name,
partition_set_name=external_partition_set.name,
solid_selection=external_partition_set.solid_selection,
mode=external_partition_set.mode,
)
def resolve_runConfigOrError(self, graphene_info):
return get_partition_config(
graphene_info,
self._external_repository_handle,
self._external_partition_set.name,
self._partition_name,
)
def resolve_tagsOrError(self, graphene_info):
return get_partition_tags(
graphene_info,
self._external_repository_handle,
self._external_partition_set.name,
self._partition_name,
)
def resolve_runs(self, graphene_info, **kwargs):
filters = kwargs.get("filter")
partition_tags = {
PARTITION_SET_TAG: self._external_partition_set.name,
PARTITION_NAME_TAG: self._partition_name,
}
if filters is not None:
filters = filters.to_selector()
runs_filter = PipelineRunsFilter(
run_ids=filters.run_ids,
pipeline_name=filters.pipeline_name,
statuses=filters.statuses,
tags=merge_dicts(filters.tags, partition_tags),
)
else:
runs_filter = PipelineRunsFilter(tags=partition_tags)
return get_runs(graphene_info,
runs_filter,
cursor=kwargs.get("cursor"),
limit=kwargs.get("limit"))
class DauphinSchedule(dauphin.ObjectType):
class Meta:
name = "Schedule"
id = dauphin.NonNull(dauphin.ID)
name = dauphin.NonNull(dauphin.String)
cron_schedule = dauphin.NonNull(dauphin.String)
pipeline_name = dauphin.NonNull(dauphin.String)
solid_selection = dauphin.List(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
execution_timezone = dauphin.Field(dauphin.String)
scheduleState = dauphin.NonNull("JobState")
partition_set = dauphin.Field("PartitionSet")
futureTicks = dauphin.NonNull("FutureJobTicks",
cursor=dauphin.Float(),
limit=dauphin.Int())
futureTick = dauphin.NonNull("FutureJobTick",
tick_timestamp=dauphin.NonNull(dauphin.Int))
def resolve_id(self, _):
return "%s:%s" % (self.name, self.pipeline_name)
def resolve_partition_set(self, graphene_info):
if self._external_schedule.partition_set_name is None:
return None
repository = graphene_info.context.get_repository_location(
self._external_schedule.handle.location_name).get_repository(
self._external_schedule.handle.repository_name)
external_partition_set = repository.get_external_partition_set(
self._external_schedule.partition_set_name)
return graphene_info.schema.type_named("PartitionSet")(
external_repository_handle=repository.handle,
external_partition_set=external_partition_set,
)
def resolve_futureTicks(self, graphene_info, **kwargs):
cursor = kwargs.get(
"cursor",
get_timestamp_from_utc_datetime(get_current_datetime_in_utc()))
limit = kwargs.get("limit", 10)
tick_times = []
time_iter = self._external_schedule.execution_time_iterator(cursor)
for _ in range(limit):
tick_times.append(next(time_iter).timestamp())
future_ticks = [
graphene_info.schema.type_named("FutureJobTick")(
self._schedule_state, tick_time) for tick_time in tick_times
]
return graphene_info.schema.type_named("FutureJobTicks")(
results=future_ticks, cursor=tick_times[-1] + 1)
def resolve_futureTick(self, graphene_info, tick_timestamp):
return graphene_info.schema.type_named("FutureJobTick")(
self._schedule_state, float(tick_timestamp))
def __init__(self, graphene_info, external_schedule):
self._external_schedule = check.inst_param(external_schedule,
"external_schedule",
ExternalSchedule)
self._schedule_state = graphene_info.context.instance.get_job_state(
self._external_schedule.get_external_origin_id())
if not self._schedule_state:
# Also include a ScheduleState for a stopped schedule that may not
# have a stored database row yet
self._schedule_state = self._external_schedule.get_default_job_state(
graphene_info.context.instance)
super(DauphinSchedule, self).__init__(
name=external_schedule.name,
cron_schedule=external_schedule.cron_schedule,
pipeline_name=external_schedule.pipeline_name,
solid_selection=external_schedule.solid_selection,
mode=external_schedule.mode,
scheduleState=graphene_info.schema.type_named("JobState")(
self._schedule_state),
execution_timezone=(self._external_schedule.execution_timezone
if self._external_schedule.execution_timezone
else pendulum.now().timezone.name),
)
class DauphinSensor(dauphin.ObjectType):
class Meta:
name = "Sensor"
id = dauphin.NonNull(dauphin.ID)
name = dauphin.NonNull(dauphin.String)
pipelineName = dauphin.NonNull(dauphin.String)
solidSelection = dauphin.List(dauphin.String)
mode = dauphin.NonNull(dauphin.String)
status = dauphin.NonNull("JobStatus")
runs = dauphin.Field(dauphin.non_null_list("PipelineRun"),
limit=dauphin.Int())
runsCount = dauphin.NonNull(dauphin.Int)
ticks = dauphin.Field(dauphin.non_null_list("JobTick"),
limit=dauphin.Int())
def resolve_id(self, _):
return "%s:%s" % (self.name, self.pipelineName)
def __init__(self, graphene_info, external_sensor):
self._external_sensor = check.inst_param(external_sensor,
"external_sensor",
ExternalSensor)
self._sensor_state = graphene_info.context.instance.get_job_state(
self._external_sensor.get_external_origin_id())
if not self._sensor_state:
# Also include a SensorState for a stopped sensor that may not
# have a stored database row yet
self._sensor_state = self._external_sensor.get_default_job_state()
super(DauphinSensor, self).__init__(
name=external_sensor.name,
pipelineName=external_sensor.pipeline_name,
solidSelection=external_sensor.solid_selection,
mode=external_sensor.mode,
)
def resolve_status(self, _graphene_info):
return self._sensor_state.status
def resolve_runs(self, graphene_info, **kwargs):
return [
graphene_info.schema.type_named("PipelineRun")(r)
for r in graphene_info.context.instance.get_runs(
filters=PipelineRunsFilter.for_sensor(self._external_sensor),
limit=kwargs.get("limit"),
)
]
def resolve_runsCount(self, graphene_info):
return graphene_info.context.instance.get_runs_count(
filters=PipelineRunsFilter.for_sensor(self._external_sensor))
def resolve_ticks(self, graphene_info, limit=None):
ticks = graphene_info.context.instance.get_job_ticks(
self._external_sensor.get_external_origin_id())
if limit:
ticks = ticks[:limit]
return [
graphene_info.schema.type_named("JobTick")(graphene_info, tick)
for tick in ticks
]
