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 ]