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 DauphinPipeline(DauphinIPipelineSnapshotMixin, dauphin.ObjectType): class Meta: name = "Pipeline" interfaces = (DauphinSolidContainer, DauphinIPipelineSnapshot) id = dauphin.NonNull(dauphin.ID) presets = dauphin.non_null_list("PipelinePreset") runs = dauphin.Field( dauphin.non_null_list("PipelineRun"), cursor=dauphin.String(), limit=dauphin.Int(), ) def __init__(self, external_pipeline): self._external_pipeline = check.inst_param( external_pipeline, "external_pipeline", ExternalPipeline ) def resolve_id(self, _graphene_info): return self._external_pipeline.get_external_origin_id() def get_represented_pipeline(self): return self._external_pipeline def resolve_presets(self, _graphene_info): return [ DauphinPipelinePreset(preset, self._external_pipeline.name) for preset in sorted(self._external_pipeline.active_presets, key=lambda item: item.name) ]
class DauphinPartitionSet(dauphin.ObjectType): class Meta: name = "PartitionSet" id = dauphin.NonNull(dauphin.ID) name = dauphin.NonNull(dauphin.String) pipeline_name = dauphin.NonNull(dauphin.String) solid_selection = dauphin.List(dauphin.NonNull(dauphin.String)) mode = dauphin.NonNull(dauphin.String) partitionsOrError = dauphin.Field( dauphin.NonNull("PartitionsOrError"), cursor=dauphin.String(), limit=dauphin.Int(), reverse=dauphin.Boolean(), ) partition = dauphin.Field("Partition", partition_name=dauphin.NonNull(dauphin.String)) partitionStatusesOrError = dauphin.NonNull("PartitionStatusesOrError") 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_id(self, _graphene_info): return self._external_partition_set.get_external_origin_id() def resolve_partitionsOrError(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, ) def resolve_partitionStatusesOrError(self, graphene_info): return get_partition_set_partition_statuses( graphene_info, self._external_repository_handle, self._external_partition_set.name)
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 DauphinPipelineRuns(dauphin.ObjectType): class Meta: name = "PipelineRuns" def __init__(self, filters, cursor, limit): self._filters = filters self._cursor = cursor self._limit = limit results = dauphin.non_null_list("PipelineRun") count = dauphin.Int() def resolve_results(self, graphene_info): return get_runs(graphene_info, self._filters, self._cursor, self._limit) def resolve_count(self, graphene_info): return get_runs_count(graphene_info, self._filters)
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 DauphinQuery(dauphin.ObjectType): class Meta(object): name = 'Query' version = dauphin.NonNull(dauphin.String) reloadSupported = dauphin.NonNull(dauphin.Boolean) pipelineOrError = dauphin.Field( dauphin.NonNull('PipelineOrError'), params=dauphin.NonNull('ExecutionSelector')) pipeline = dauphin.Field(dauphin.NonNull('Pipeline'), params=dauphin.NonNull('ExecutionSelector')) pipelinesOrError = dauphin.NonNull('PipelinesOrError') pipelines = dauphin.Field(dauphin.NonNull('PipelineConnection')) pipelineSnapshot = dauphin.Field( dauphin.NonNull('PipelineSnapshot'), snapshotId=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) pipelineSnapshotOrError = dauphin.Field( dauphin.NonNull('PipelineSnapshotOrError'), snapshotId=dauphin.String(), activePipelineName=dauphin.String(), ) scheduler = dauphin.Field(dauphin.NonNull('SchedulerOrError')) scheduleOrError = dauphin.Field( dauphin.NonNull('ScheduleOrError'), schedule_name=dauphin.NonNull(dauphin.String), limit=dauphin.Int(), ) partitionSetsOrError = dauphin.Field( dauphin.NonNull('PartitionSetsOrError'), pipelineName=dauphin.String()) partitionSetOrError = dauphin.Field(dauphin.NonNull('PartitionSetOrError'), 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') usedSolids = dauphin.Field(dauphin.non_null_list('UsedSolid')) usedSolid = dauphin.Field('UsedSolid', name=dauphin.NonNull(dauphin.String)) isPipelineConfigValid = dauphin.Field( dauphin.NonNull('PipelineConfigValidationResult'), args={ 'pipeline': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'environmentConfigData': dauphin.Argument('EnvironmentConfigData'), 'mode': dauphin.Argument(dauphin.NonNull(dauphin.String)), }, ) executionPlan = dauphin.Field( dauphin.NonNull('ExecutionPlanResult'), args={ 'pipeline': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'environmentConfigData': dauphin.Argument('EnvironmentConfigData'), 'mode': dauphin.Argument(dauphin.NonNull(dauphin.String)), }, ) environmentSchemaOrError = dauphin.Field( dauphin.NonNull('EnvironmentSchemaOrError'), args={ 'selector': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'mode': dauphin.Argument(dauphin.String), }, description= '''Fetch an environment schema given an execution selection and a mode. See the descripton on EnvironmentSchema for more information.''', ) instance = dauphin.NonNull('Instance') def resolve_pipelineSnapshot(self, graphene_info, **kwargs): return get_pipeline_snapshot(graphene_info, kwargs['snapshotId']) def resolve_pipelineSnapshotOrError(self, graphene_info, **kwargs): snapshot_id_arg = kwargs.get('snapshotId') pipeline_name_arg = kwargs.get('activePipelineName') check.invariant( not (snapshot_id_arg and pipeline_name_arg), 'Cannot pass both snapshotId and activePipelineName', ) check.invariant(snapshot_id_arg or pipeline_name_arg, 'Must set one of snapshotId or activePipelineName') if pipeline_name_arg: return get_pipeline_snapshot_or_error_from_pipeline_name( graphene_info, pipeline_name_arg) 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_reloadSupported(self, graphene_info): if isinstance(graphene_info.context, DagsterSnapshotGraphQLContext): return False return graphene_info.context.reloader.is_reload_supported def resolve_scheduler(self, graphene_info): return get_scheduler_or_error(graphene_info) def resolve_scheduleOrError(self, graphene_info, schedule_name): return get_schedule_or_error(graphene_info, schedule_name) def resolve_pipelineOrError(self, graphene_info, **kwargs): return get_pipeline_or_error(graphene_info, kwargs['params'].to_selector()) def resolve_pipeline(self, graphene_info, **kwargs): return get_pipeline_or_raise(graphene_info, kwargs['params'].to_selector()) def resolve_pipelinesOrError(self, graphene_info): return get_pipelines_or_error(graphene_info) def resolve_pipelines(self, graphene_info): return get_pipelines_or_raise(graphene_info) 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_partitionSetsOrError(self, graphene_info, **kwargs): pipeline_name = kwargs.get('pipelineName') return get_partition_sets_or_error(graphene_info, pipeline_name) def resolve_partitionSetOrError(self, graphene_info, partitionSetName): return get_partition_set(graphene_info, partitionSetName) def resolve_pipelineRunTags(self, graphene_info): return get_run_tags(graphene_info) def resolve_usedSolid(self, graphene_info, name): return get_solid(graphene_info, name) def resolve_usedSolids(self, graphene_info): return get_solids(graphene_info) def resolve_isPipelineConfigValid(self, graphene_info, pipeline, **kwargs): return validate_pipeline_config( graphene_info, pipeline.to_selector(), kwargs.get('environmentConfigData'), kwargs.get('mode'), ) def resolve_executionPlan(self, graphene_info, pipeline, **kwargs): return get_execution_plan( graphene_info, pipeline.to_selector(), kwargs.get('environmentConfigData'), kwargs.get('mode'), ) def resolve_environmentSchemaOrError(self, graphene_info, **kwargs): return resolve_environment_schema_or_error( graphene_info, kwargs['selector'].to_selector(), kwargs.get('mode')) def resolve_instance(self, graphene_info): return graphene_info.schema.type_named('Instance')( graphene_info.context.instance)
class DauphinRunningSchedule(dauphin.ObjectType): class Meta(object): name = 'RunningSchedule' schedule_definition = dauphin.NonNull('ScheduleDefinition') python_path = dauphin.Field(dauphin.String) repository_path = dauphin.Field(dauphin.String) status = dauphin.NonNull('ScheduleStatus') runs = dauphin.Field(dauphin.non_null_list('PipelineRun'), limit=dauphin.Int()) runs_count = dauphin.NonNull(dauphin.Int) ticks = dauphin.Field(dauphin.non_null_list('ScheduleTick'), limit=dauphin.Int()) ticks_count = dauphin.NonNull(dauphin.Int) stats = dauphin.NonNull('ScheduleTickStatsSnapshot') # TODO: Delete attempts and attempts_count in 0.8.0 release # https://github.com/dagster-io/dagster/issues/228 attempts = dauphin.Field(dauphin.non_null_list('ScheduleAttempt'), limit=dauphin.Int()) attempts_count = dauphin.NonNull(dauphin.Int) logs_path = dauphin.NonNull(dauphin.String) def __init__(self, graphene_info, schedule): self._schedule = check.inst_param(schedule, 'schedule', Schedule) super(DauphinRunningSchedule, self).__init__( schedule_definition=graphene_info.schema.type_named( 'ScheduleDefinition')( graphene_info=graphene_info, schedule_def=get_dagster_schedule_def( graphene_info, schedule.name), ), status=schedule.status, python_path=schedule.python_path, repository_path=schedule.repository_path, ) # TODO: Delete in 0.8.0 release # https://github.com/dagster-io/dagster/issues/228 def resolve_attempts(self, graphene_info, **kwargs): limit = kwargs.get('limit') results = get_schedule_attempt_filenames(graphene_info, self._schedule.name) if limit is None: limit = len(results) latest_results = heapq.nlargest(limit, results, key=os.path.getctime) attempts = [] for result_path in latest_results: with open(result_path, 'r') as f: line = f.readline() if not line: continue # File is empty start_scheduled_execution_response = json.loads(line) run = None if 'errors' in start_scheduled_execution_response: status = DauphinScheduleAttemptStatus.ERROR json_result = start_scheduled_execution_response['errors'] else: json_result = start_scheduled_execution_response['data'][ 'startScheduledExecution'] typename = json_result['__typename'] if (typename == 'StartPipelineRunSuccess' or typename == 'LaunchPipelineRunSuccess'): status = DauphinScheduleAttemptStatus.SUCCESS run_id = json_result['run']['runId'] if graphene_info.context.instance.has_run(run_id): run = graphene_info.schema.type_named( 'PipelineRun')(graphene_info.context.instance. get_run_by_id(run_id)) elif typename == 'ScheduledExecutionBlocked': status = DauphinScheduleAttemptStatus.SKIPPED else: status = DauphinScheduleAttemptStatus.ERROR attempts.append( graphene_info.schema.type_named('ScheduleAttempt')( time=os.path.getctime(result_path), json_result=json.dumps(json_result), status=status, run=run, )) return attempts # TODO: Delete in 0.8.0 release # https://github.com/dagster-io/dagster/issues/228 def resolve_attempts_count(self, graphene_info): attempt_files = get_schedule_attempt_filenames(graphene_info, self._schedule.name) return len(attempt_files) # TODO: Delete in 0.8.0 release # https://github.com/dagster-io/dagster/issues/228 def resolve_logs_path(self, graphene_info): instance = graphene_info.context.instance repository = graphene_info.context.get_repository_definition() return instance.log_path_for_schedule(repository, self._schedule.name) def resolve_stats(self, graphene_info): repository = graphene_info.context.get_repository_definition() stats = graphene_info.context.instance.get_schedule_tick_stats_by_schedule( repository, self._schedule.name) return graphene_info.schema.type_named('ScheduleTickStatsSnapshot')( stats) def resolve_ticks(self, graphene_info, limit=None): repository = graphene_info.context.get_repository_definition() # TODO: Add cursor limit argument to get_schedule_ticks_by_schedule # https://github.com/dagster-io/dagster/issues/2291 ticks = graphene_info.context.instance.get_schedule_ticks_by_schedule( repository, self._schedule.name) if not limit: tick_subset = ticks else: tick_subset = ticks[:limit] return [ graphene_info.schema.type_named('ScheduleTick')( tick_id=tick.tick_id, status=tick.status, timestamp=tick.timestamp, tick_specific_data=tick_specific_data_from_dagster_tick( graphene_info, tick), ) for tick in tick_subset ] def resolve_ticks_count(self, graphene_info): repository = graphene_info.context.get_repository_definition() ticks = graphene_info.context.instance.get_schedule_ticks_by_schedule( repository, self._schedule.name) return len(ticks) 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_schedule(self._schedule), limit=kwargs.get('limit'), ) ] def resolve_runs_count(self, graphene_info): return graphene_info.context.instance.get_runs_count( filters=PipelineRunsFilter.for_schedule(self._schedule))
class DauphinScheduleState(dauphin.ObjectType): class Meta(object): name = 'ScheduleState' schedule_origin_id = dauphin.NonNull(dauphin.String) schedule_name = dauphin.NonNull(dauphin.String) cron_schedule = dauphin.NonNull(dauphin.String) status = dauphin.NonNull('ScheduleStatus') runs = dauphin.Field(dauphin.non_null_list('PipelineRun'), limit=dauphin.Int()) runs_count = dauphin.NonNull(dauphin.Int) ticks = dauphin.Field(dauphin.non_null_list('ScheduleTick'), limit=dauphin.Int()) ticks_count = dauphin.NonNull(dauphin.Int) stats = dauphin.NonNull('ScheduleTickStatsSnapshot') logs_path = dauphin.NonNull(dauphin.String) running_schedule_count = dauphin.NonNull(dauphin.Int) repository_origin_id = dauphin.NonNull(dauphin.String) id = dauphin.NonNull(dauphin.ID) def __init__(self, _graphene_info, schedule_state): self._schedule_state = check.inst_param(schedule_state, 'schedule', ScheduleState) self._external_schedule_origin_id = self._schedule_state.schedule_origin_id super(DauphinScheduleState, self).__init__( schedule_origin_id=schedule_state.schedule_origin_id, schedule_name=schedule_state.name, cron_schedule=schedule_state.cron_schedule, status=schedule_state.status, ) def resolve_id(self, _graphene_info): return self._external_schedule_origin_id def resolve_running_schedule_count(self, graphene_info): running_schedule_count = graphene_info.context.instance.running_schedule_count( self._external_schedule_origin_id) return running_schedule_count def resolve_stats(self, graphene_info): stats = graphene_info.context.instance.get_schedule_tick_stats( self._external_schedule_origin_id) return graphene_info.schema.type_named('ScheduleTickStatsSnapshot')( stats) def resolve_ticks(self, graphene_info, limit=None): # TODO: Add cursor limit argument to get_schedule_ticks_by_schedule # https://github.com/dagster-io/dagster/issues/2291 ticks = graphene_info.context.instance.get_schedule_ticks( self._external_schedule_origin_id) if not limit: tick_subset = ticks else: tick_subset = ticks[:limit] return [ graphene_info.schema.type_named('ScheduleTick')( tick_id=tick.tick_id, status=tick.status, timestamp=tick.timestamp, tick_specific_data=tick_specific_data_from_dagster_tick( graphene_info, tick), ) for tick in tick_subset ] def resolve_ticks_count(self, graphene_info): ticks = graphene_info.context.instance.get_schedule_ticks( self._external_schedule_origin_id) return len(ticks) 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_schedule(self._schedule_state), limit=kwargs.get('limit'), ) ] def resolve_runs_count(self, graphene_info): return graphene_info.context.instance.get_runs_count( filters=PipelineRunsFilter.for_schedule(self._schedule_state)) def resolve_repository_origin_id(self, _graphene_info): return self._schedule_state.repository_origin_id
class DauphinRunningSchedule(dauphin.ObjectType): class Meta(object): name = 'RunningSchedule' id = dauphin.NonNull(dauphin.String) schedule_definition = dauphin.NonNull('ScheduleDefinition') python_path = dauphin.Field(dauphin.String) repository_path = dauphin.Field(dauphin.String) status = dauphin.NonNull('ScheduleStatus') runs = dauphin.Field(dauphin.non_null_list('PipelineRun'), limit=dauphin.Int()) runs_count = dauphin.NonNull(dauphin.Int) attempts = dauphin.Field(dauphin.non_null_list('ScheduleAttempt'), limit=dauphin.Int()) attempts_count = dauphin.NonNull(dauphin.Int) logs_path = dauphin.NonNull(dauphin.String) def __init__(self, graphene_info, schedule): self._schedule = check.inst_param(schedule, 'schedule', Schedule) super(DauphinRunningSchedule, self).__init__( id=schedule.schedule_id, schedule_definition=graphene_info.schema.type_named('ScheduleDefinition')( graphene_info=graphene_info, schedule_def=get_dagster_schedule_def(graphene_info, schedule.name), ), status=schedule.status, python_path=schedule.python_path, repository_path=schedule.repository_path, ) def resolve_attempts(self, graphene_info, **kwargs): limit = kwargs.get('limit') results = get_schedule_attempt_filenames(graphene_info, self._schedule.name) if limit is None: limit = len(results) latest_results = heapq.nlargest(limit, results, key=os.path.getctime) attempts = [] for result_path in latest_results: with open(result_path, 'r') as f: line = f.readline() if not line: continue # File is empty start_scheduled_execution_response = json.loads(line) run = None if 'errors' in start_scheduled_execution_response: status = DauphinScheduleAttemptStatus.ERROR json_result = start_scheduled_execution_response['errors'] else: json_result = start_scheduled_execution_response['data'][ 'startScheduledExecution' ] typename = json_result['__typename'] if typename == 'StartPipelineExecutionSuccess': status = DauphinScheduleAttemptStatus.SUCCESS run_id = json_result['run']['runId'] run = graphene_info.schema.type_named('PipelineRun')( graphene_info.context.instance.get_run_by_id(run_id) ) elif typename == 'ScheduleExecutionBlocked': status = DauphinScheduleAttemptStatus.SKIPPED else: status = DauphinScheduleAttemptStatus.ERROR attempts.append( graphene_info.schema.type_named('ScheduleAttempt')( time=os.path.getctime(result_path), json_result=json.dumps(json_result), status=status, run=run, ) ) return attempts def resolve_attempts_count(self, graphene_info): attempt_files = get_schedule_attempt_filenames(graphene_info, self._schedule.name) return len(attempt_files) def resolve_logs_path(self, graphene_info): scheduler = graphene_info.context.get_scheduler() return scheduler.log_path_for_schedule(self._schedule.name) 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( tags={'dagster/schedule_id': self._schedule.schedule_id} ), limit=kwargs.get('limit'), ) ] def resolve_runs_count(self, graphene_info): return graphene_info.context.instance.get_runs_count( filter=PipelineRunsFilter(tags=[("dagster/schedule_id", self._schedule.schedule_id)]) )
class DauphinRunningSchedule(dauphin.ObjectType): class Meta(object): name = 'RunningSchedule' schedule_definition = dauphin.NonNull('ScheduleDefinition') python_path = dauphin.Field(dauphin.String) repository_path = dauphin.Field(dauphin.String) status = dauphin.NonNull('ScheduleStatus') runs = dauphin.Field(dauphin.non_null_list('PipelineRun'), limit=dauphin.Int()) runs_count = dauphin.NonNull(dauphin.Int) ticks = dauphin.Field(dauphin.non_null_list('ScheduleTick'), limit=dauphin.Int()) ticks_count = dauphin.NonNull(dauphin.Int) stats = dauphin.NonNull('ScheduleTickStatsSnapshot') logs_path = dauphin.NonNull(dauphin.String) running_schedule_count = dauphin.NonNull(dauphin.Int) def __init__(self, graphene_info, schedule): self._schedule = check.inst_param(schedule, 'schedule', Schedule) external_repository = graphene_info.context.legacy_external_repository external_schedule = external_repository.get_external_schedule(schedule.name) super(DauphinRunningSchedule, self).__init__( schedule_definition=graphene_info.schema.type_named('ScheduleDefinition')( schedule_def=get_dagster_schedule_def(graphene_info, schedule.name), external_schedule=external_schedule, ), status=schedule.status, python_path=schedule.python_path, repository_path=schedule.repository_path, ) def resolve_running_schedule_count(self, graphene_info): external_repository = graphene_info.context.legacy_external_repository running_schedule_count = graphene_info.context.instance.running_schedule_count( external_repository.name, self._schedule.name ) return running_schedule_count def resolve_stats(self, graphene_info): external_repository = graphene_info.context.legacy_external_repository stats = graphene_info.context.instance.get_schedule_tick_stats_by_schedule( external_repository.name, self._schedule.name ) return graphene_info.schema.type_named('ScheduleTickStatsSnapshot')(stats) def resolve_ticks(self, graphene_info, limit=None): external_repository = graphene_info.context.legacy_external_repository # TODO: Add cursor limit argument to get_schedule_ticks_by_schedule # https://github.com/dagster-io/dagster/issues/2291 ticks = graphene_info.context.instance.get_schedule_ticks_by_schedule( external_repository.name, self._schedule.name ) if not limit: tick_subset = ticks else: tick_subset = ticks[:limit] return [ graphene_info.schema.type_named('ScheduleTick')( tick_id=tick.tick_id, status=tick.status, timestamp=tick.timestamp, tick_specific_data=tick_specific_data_from_dagster_tick(graphene_info, tick), ) for tick in tick_subset ] def resolve_ticks_count(self, graphene_info): external_repository = graphene_info.context.legacy_external_repository ticks = graphene_info.context.instance.get_schedule_ticks_by_schedule( external_repository.name, self._schedule.name ) return len(ticks) 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_schedule(self._schedule), limit=kwargs.get('limit'), ) ] def resolve_runs_count(self, graphene_info): return graphene_info.context.instance.get_runs_count( filters=PipelineRunsFilter.for_schedule(self._schedule) )
class DauphinJobState(dauphin.ObjectType): class Meta: name = "JobState" id = dauphin.NonNull(dauphin.ID) name = dauphin.NonNull(dauphin.String) jobType = dauphin.NonNull("JobType") status = dauphin.NonNull("JobStatus") repositoryOrigin = dauphin.NonNull("RepositoryOrigin") jobSpecificData = dauphin.Field("JobSpecificData") runs = dauphin.Field(dauphin.non_null_list("PipelineRun"), limit=dauphin.Int()) runsCount = dauphin.NonNull(dauphin.Int) ticks = dauphin.Field( dauphin.non_null_list("JobTick"), dayRange=dauphin.Int(), dayOffset=dauphin.Int(), limit=dauphin.Int(), ) nextTick = dauphin.Field("FutureJobTick") runningCount = dauphin.NonNull(dauphin.Int) # remove with cron scheduler def __init__(self, job_state): self._job_state = check.inst_param(job_state, "job_state", JobState) super(DauphinJobState, self).__init__( id=job_state.job_origin_id, name=job_state.name, jobType=job_state.job_type, status=job_state.status, ) def resolve_repositoryOrigin(self, graphene_info): origin = self._job_state.origin.external_repository_origin return graphene_info.schema.type_named("RepositoryOrigin")(origin) def resolve_jobSpecificData(self, graphene_info): if not self._job_state.job_specific_data: return None if self._job_state.job_type == JobType.SENSOR: return graphene_info.schema.type_named("SensorJobData")( self._job_state.job_specific_data) if self._job_state.job_type == JobType.SCHEDULE: return graphene_info.schema.type_named("ScheduleJobData")( self._job_state.job_specific_data) return None def resolve_runs(self, graphene_info, **kwargs): if self._job_state.job_type == JobType.SENSOR: filters = PipelineRunsFilter.for_sensor(self._job_state) else: filters = PipelineRunsFilter.for_schedule(self._job_state) return [ graphene_info.schema.type_named("PipelineRun")(r) for r in graphene_info.context.instance.get_runs( filters=filters, limit=kwargs.get("limit"), ) ] def resolve_runsCount(self, graphene_info): if self._job_state.job_type == JobType.SENSOR: filters = PipelineRunsFilter.for_sensor(self._job_state) else: filters = PipelineRunsFilter.for_schedule(self._job_state) return graphene_info.context.instance.get_runs_count(filters=filters) def resolve_ticks(self, graphene_info, dayRange=None, dayOffset=None, limit=None): before = pendulum.now("UTC").subtract( days=dayOffset).timestamp() if dayOffset else None after = (pendulum.now("UTC").subtract( days=dayRange + (dayOffset or 0)).timestamp() if dayRange else None) return [ graphene_info.schema.type_named("JobTick")(graphene_info, tick) for tick in graphene_info.context.instance.get_job_ticks( self._job_state.job_origin_id, before=before, after=after, limit=limit) ] def resolve_nextTick(self, graphene_info): # sensor if self._job_state.job_type == JobType.SENSOR: return get_sensor_next_tick(graphene_info, self._job_state) else: return get_schedule_next_tick(graphene_info, self._job_state) def resolve_runningCount(self, graphene_info): if self._job_state.job_type == JobType.SENSOR: return 1 if self._job_state.status == JobStatus.RUNNING else 0 else: return graphene_info.context.instance.running_schedule_count( self._job_state.job_origin_id)
class DauphinQuery(dauphin.ObjectType): class Meta: name = 'Query' version = dauphin.NonNull(dauphin.String) reloadSupported = dauphin.NonNull(dauphin.Boolean) pipelineOrError = dauphin.Field( dauphin.NonNull('PipelineOrError'), params=dauphin.NonNull('ExecutionSelector') ) pipeline = dauphin.Field( dauphin.NonNull('Pipeline'), params=dauphin.NonNull('ExecutionSelector') ) pipelinesOrError = dauphin.NonNull('PipelinesOrError') pipelines = dauphin.Field(dauphin.NonNull('PipelineConnection')) configTypeOrError = dauphin.Field( dauphin.NonNull('ConfigTypeOrError'), pipelineName=dauphin.Argument(dauphin.NonNull(dauphin.String)), configTypeName=dauphin.Argument(dauphin.NonNull(dauphin.String)), mode=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) runtimeTypeOrError = dauphin.Field( dauphin.NonNull('RuntimeTypeOrError'), pipelineName=dauphin.Argument(dauphin.NonNull(dauphin.String)), runtimeTypeName=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) scheduler = dauphin.Field(dauphin.NonNull('SchedulerOrError')) pipelineRunsOrError = dauphin.Field( dauphin.NonNull('PipelineRunsOrError'), filter=dauphin.Argument(dauphin.NonNull('PipelineRunsFilter')), cursor=dauphin.String(), limit=dauphin.Int(), ) pipelineRunOrError = dauphin.Field( dauphin.NonNull('PipelineRunOrError'), runId=dauphin.NonNull(dauphin.ID) ) pipelineRunTags = dauphin.non_null_list('PipelineTagAndValues') isPipelineConfigValid = dauphin.Field( dauphin.NonNull('PipelineConfigValidationResult'), args={ 'pipeline': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'environmentConfigData': dauphin.Argument('EnvironmentConfigData'), 'mode': dauphin.Argument(dauphin.NonNull(dauphin.String)), }, ) executionPlan = dauphin.Field( dauphin.NonNull('ExecutionPlanResult'), args={ 'pipeline': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'environmentConfigData': dauphin.Argument('EnvironmentConfigData'), 'mode': dauphin.Argument(dauphin.NonNull(dauphin.String)), }, ) environmentSchemaOrError = dauphin.Field( dauphin.NonNull('EnvironmentSchemaOrError'), args={ 'selector': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'mode': dauphin.Argument(dauphin.String), }, description='''Fetch an environment schema given an execution selection and a mode. See the descripton on EnvironmentSchema for more information.''', ) instance = dauphin.NonNull('Instance') def resolve_configTypeOrError(self, graphene_info, **kwargs): return get_config_type( graphene_info, kwargs['pipelineName'], kwargs['configTypeName'], kwargs.get('mode') ) def resolve_runtimeTypeOrError(self, graphene_info, **kwargs): return get_runtime_type(graphene_info, kwargs['pipelineName'], kwargs['runtimeTypeName']) def resolve_version(self, graphene_info): return graphene_info.context.version def resolve_reloadSupported(self, graphene_info): return graphene_info.context.reloader.is_reload_supported def resolve_scheduler(self, graphene_info): return get_scheduler_or_error(graphene_info) def resolve_pipelineOrError(self, graphene_info, **kwargs): return get_pipeline_or_error(graphene_info, kwargs['params'].to_selector()) def resolve_pipeline(self, graphene_info, **kwargs): return get_pipeline_or_raise(graphene_info, kwargs['params'].to_selector()) def resolve_pipelinesOrError(self, graphene_info): return get_pipelines_or_error(graphene_info) def resolve_pipelines(self, graphene_info): return get_pipelines_or_raise(graphene_info) def resolve_pipelineRunsOrError(self, graphene_info, **kwargs): filters = kwargs['filter'].to_selector() provided = [ i for i in [filters.run_id, filters.pipeline, filters.tag_key, filters.status] if i ] if len(provided) > 1: return graphene_info.schema.type_named('InvalidPipelineRunsFilterError')( message="You may only provide one of the filter options." ) 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(graphene_info, runId) def resolve_pipelineRunTags(self, graphene_info): return get_run_tags(graphene_info) def resolve_isPipelineConfigValid(self, graphene_info, pipeline, **kwargs): return validate_pipeline_config( graphene_info, pipeline.to_selector(), kwargs.get('environmentConfigData'), kwargs.get('mode'), ) def resolve_executionPlan(self, graphene_info, pipeline, **kwargs): return get_execution_plan( graphene_info, pipeline.to_selector(), kwargs.get('environmentConfigData'), kwargs.get('mode'), ) def resolve_environmentSchemaOrError(self, graphene_info, **kwargs): return resolve_environment_schema_or_error( graphene_info, kwargs['selector'].to_selector(), kwargs.get('mode') ) def resolve_instance(self, graphene_info): return graphene_info.schema.type_named('Instance')(graphene_info.context.instance)
class DauphinIPipelineSnapshotMixin(object): # Mixin this class to implement IPipelineSnapshot # # Graphene has some strange properties that make it so that you cannot # implement ABCs nor use properties in an overridable way. So the way # the mixin works is that the target classes have to have a method # get_represented_pipeline() # def get_represented_pipeline(self): raise NotImplementedError() name = dauphin.NonNull(dauphin.String) description = dauphin.String() pipeline_snapshot_id = dauphin.NonNull(dauphin.String) dagster_types = dauphin.non_null_list('DagsterType') dagster_type_or_error = dauphin.Field( dauphin.NonNull('DagsterTypeOrError'), dagsterTypeName=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) solids = dauphin.non_null_list('Solid') modes = dauphin.non_null_list('Mode') solid_handles = dauphin.Field(dauphin.non_null_list('SolidHandle'), parentHandleID=dauphin.String()) solid_handle = dauphin.Field( 'SolidHandle', handleID=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) tags = dauphin.non_null_list('PipelineTag') runs = dauphin.Field( dauphin.non_null_list('PipelineRun'), cursor=dauphin.String(), limit=dauphin.Int(), ) schedules = dauphin.non_null_list('RunningSchedule') def resolve_pipeline_snapshot_id(self, _): return self.get_represented_pipeline().identifying_pipeline_snapshot_id def resolve_name(self, _): return self.get_represented_pipeline().name def resolve_description(self, _): return self.get_represented_pipeline().description def resolve_dagster_types(self, _graphene_info): represented_pipeline = self.get_represented_pipeline() return sorted( list( map( lambda dt: to_dauphin_dagster_type( represented_pipeline.pipeline_snapshot, dt.key), [ t for t in represented_pipeline.dagster_type_snaps if t.name ], )), key=lambda dagster_type: dagster_type.name, ) @capture_dauphin_error def resolve_dagster_type_or_error(self, _, **kwargs): type_name = kwargs['dagsterTypeName'] represented_pipeline = self.get_represented_pipeline() if not represented_pipeline.has_dagster_type_named(type_name): from .errors import DauphinDagsterTypeNotFoundError raise UserFacingGraphQLError( DauphinDagsterTypeNotFoundError(dagster_type_name=type_name)) return to_dauphin_dagster_type( represented_pipeline.pipeline_snapshot, represented_pipeline.get_dagster_type_by_name(type_name).key, ) def resolve_solids(self, _graphene_info): represented_pipeline = self.get_represented_pipeline() return build_dauphin_solids( represented_pipeline, represented_pipeline.dep_structure_index, ) def resolve_modes(self, _): represented_pipeline = self.get_represented_pipeline() return [ DauphinMode(represented_pipeline.config_schema_snapshot, mode_def_snap) for mode_def_snap in sorted(represented_pipeline.mode_def_snaps, key=lambda item: item.name) ] def resolve_solid_handle(self, _graphene_info, handleID): return _get_solid_handles( self.get_represented_pipeline()).get(handleID) def resolve_solid_handles(self, _graphene_info, **kwargs): handles = _get_solid_handles(self.get_represented_pipeline()) parentHandleID = kwargs.get('parentHandleID') if parentHandleID == "": handles = { key: handle for key, handle in handles.items() if not handle.parent } elif parentHandleID is not None: handles = { key: handle for key, handle in handles.items() if handle.parent and handle.parent.handleID.to_string() == parentHandleID } return [handles[key] for key in sorted(handles)] def resolve_tags(self, graphene_info): represented_pipeline = self.get_represented_pipeline() return [ graphene_info.schema.type_named('PipelineTag')(key=key, value=value) for key, value in represented_pipeline.pipeline_snapshot.tags.items() ] def resolve_solidSubset(self, _graphene_info): return self.get_represented_pipeline().solid_subset def resolve_runs(self, graphene_info, **kwargs): runs_filter = PipelineRunsFilter( pipeline_name=self.get_represented_pipeline().name) return get_runs(graphene_info, runs_filter, kwargs.get('cursor'), kwargs.get('limit')) def resolve_schedules(self, graphene_info): external_repository = graphene_info.context.legacy_external_repository schedules = graphene_info.context.instance.all_schedules( external_repository.name) return [ graphene_info.schema.type_named('RunningSchedule')( graphene_info, schedule=schedule) for schedule in schedules if get_dagster_schedule_def(graphene_info, schedule.name).name == self.get_represented_pipeline().name ]
class DauphinJobState(dauphin.ObjectType): class Meta: name = "JobState" id = dauphin.NonNull(dauphin.ID) name = dauphin.NonNull(dauphin.String) jobType = dauphin.NonNull("JobType") status = dauphin.NonNull("JobStatus") repositoryOrigin = dauphin.NonNull("RepositoryOrigin") jobSpecificData = dauphin.Field("JobSpecificData") 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()) runningCount = dauphin.NonNull(dauphin.Int) # remove with cron scheduler def __init__(self, job_state): self._job_state = check.inst_param(job_state, "job_state", JobState) super(DauphinJobState, self).__init__( id=job_state.job_origin_id, name=job_state.name, jobType=job_state.job_type, status=job_state.status, ) def resolve_repositoryOrigin(self, graphene_info): origin = self._job_state.origin.external_repository_origin return graphene_info.schema.type_named("RepositoryOrigin")(origin) def resolve_jobSpecificData(self, graphene_info): if not self._job_state.job_specific_data: return None if self._job_state.job_type == JobType.SENSOR: return graphene_info.schema.type_named("SensorJobData")( self._job_state.job_specific_data ) if self._job_state.job_type == JobType.SCHEDULE: return graphene_info.schema.type_named("ScheduleJobData")( self._job_state.job_specific_data ) return None def resolve_runs(self, graphene_info, **kwargs): if self._job_state.job_type == JobType.SENSOR: filters = PipelineRunsFilter.for_sensor(self._job_state) else: filters = PipelineRunsFilter.for_schedule(self._job_state) return [ graphene_info.schema.type_named("PipelineRun")(r) for r in graphene_info.context.instance.get_runs( filters=filters, limit=kwargs.get("limit"), ) ] def resolve_runsCount(self, graphene_info): if self._job_state.job_type == JobType.SENSOR: filters = PipelineRunsFilter.for_sensor(self._job_state) else: filters = PipelineRunsFilter.for_schedule(self._job_state) return graphene_info.context.instance.get_runs_count(filters=filters) def resolve_ticks(self, graphene_info, limit=None): ticks = graphene_info.context.instance.get_job_ticks(self._job_state.job_origin_id) if limit: ticks = ticks[:limit] return [graphene_info.schema.type_named("JobTick")(graphene_info, tick) for tick in ticks] def resolve_runningCount(self, graphene_info): if self._job_state.job_type == JobType.SENSOR: return 1 if self._job_state.status == JobStatus.RUNNING else 0 else: return graphene_info.context.instance.running_schedule_count( self._job_state.job_origin_id )
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 ]
class DauphinQuery(dauphin.ObjectType): class Meta(object): name = 'Query' version = dauphin.NonNull(dauphin.String) reloadSupported = dauphin.NonNull(dauphin.Boolean) pipelineOrError = dauphin.Field( dauphin.NonNull('PipelineOrError'), params=dauphin.NonNull('ExecutionSelector')) pipeline = dauphin.Field(dauphin.NonNull('Pipeline'), params=dauphin.NonNull('ExecutionSelector')) pipelinesOrError = dauphin.NonNull('PipelinesOrError') pipelines = dauphin.Field(dauphin.NonNull('PipelineConnection')) runtimeTypeOrError = dauphin.Field( dauphin.NonNull('RuntimeTypeOrError'), pipelineName=dauphin.Argument(dauphin.NonNull(dauphin.String)), runtimeTypeName=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) scheduler = dauphin.Field(dauphin.NonNull('SchedulerOrError')) scheduleOrError = dauphin.Field( dauphin.NonNull('ScheduleOrError'), schedule_name=dauphin.NonNull(dauphin.String), limit=dauphin.Int(), ) partitionSetsOrError = dauphin.Field( dauphin.NonNull('PartitionSetsOrError'), pipelineName=dauphin.String()) partitionSetOrError = dauphin.Field(dauphin.NonNull('PartitionSetOrError'), 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') usedSolids = dauphin.Field(dauphin.non_null_list('UsedSolid')) usedSolid = dauphin.Field('UsedSolid', name=dauphin.NonNull(dauphin.String)) isPipelineConfigValid = dauphin.Field( dauphin.NonNull('PipelineConfigValidationResult'), args={ 'pipeline': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'environmentConfigData': dauphin.Argument('EnvironmentConfigData'), 'mode': dauphin.Argument(dauphin.NonNull(dauphin.String)), }, ) executionPlan = dauphin.Field( dauphin.NonNull('ExecutionPlanResult'), args={ 'pipeline': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'environmentConfigData': dauphin.Argument('EnvironmentConfigData'), 'mode': dauphin.Argument(dauphin.NonNull(dauphin.String)), }, ) environmentSchemaOrError = dauphin.Field( dauphin.NonNull('EnvironmentSchemaOrError'), args={ 'selector': dauphin.Argument(dauphin.NonNull('ExecutionSelector')), 'mode': dauphin.Argument(dauphin.String), }, description= '''Fetch an environment schema given an execution selection and a mode. See the descripton on EnvironmentSchema for more information.''', ) instance = dauphin.NonNull('Instance') def resolve_runtimeTypeOrError(self, graphene_info, **kwargs): return get_dagster_type(graphene_info, kwargs['pipelineName'], kwargs['runtimeTypeName']) def resolve_version(self, graphene_info): return graphene_info.context.version def resolve_reloadSupported(self, graphene_info): return graphene_info.context.reloader.is_reload_supported def resolve_scheduler(self, graphene_info): return get_scheduler_or_error(graphene_info) def resolve_scheduleOrError(self, graphene_info, schedule_name): return get_schedule_or_error(graphene_info, schedule_name) def resolve_pipelineOrError(self, graphene_info, **kwargs): return get_pipeline_or_error(graphene_info, kwargs['params'].to_selector()) def resolve_pipeline(self, graphene_info, **kwargs): return get_pipeline_or_raise(graphene_info, kwargs['params'].to_selector()) def resolve_pipelinesOrError(self, graphene_info): return get_pipelines_or_error(graphene_info) def resolve_pipelines(self, graphene_info): return get_pipelines_or_raise(graphene_info) 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(graphene_info, runId) def resolve_partitionSetsOrError(self, graphene_info, **kwargs): pipeline_name = kwargs.get('pipelineName') return get_partition_sets_or_error(graphene_info, pipeline_name) def resolve_partitionSetOrError(self, graphene_info, partitionSetName): return get_partition_set(graphene_info, partitionSetName) def resolve_pipelineRunTags(self, graphene_info): return get_run_tags(graphene_info) def resolve_usedSolid(self, graphene_info, name): repository = graphene_info.context.repository_definition invocations = [] definition = None for pipeline in repository.get_all_pipelines(): for handle in build_dauphin_solid_handles( pipeline.get_pipeline_snapshot(), pipeline): if handle.handleID.definition_name == name: if definition is None: definition = handle.solid.resolve_definition( graphene_info) invocations.append( DauphinSolidInvocationSite(pipeline=pipeline, solidHandle=handle)) return DauphinUsedSolid(definition=definition, invocations=invocations) def resolve_usedSolids(self, graphene_info): repository = graphene_info.context.repository_definition inv_by_def_name = defaultdict(list) definitions = [] for pipeline in repository.get_all_pipelines(): for handle in build_dauphin_solid_handles( pipeline.get_pipeline_snapshot(), pipeline): definition = handle.solid.resolve_definition(graphene_info) if definition.name not in inv_by_def_name: definitions.append(definition) inv_by_def_name[definition.name].append( DauphinSolidInvocationSite(pipeline=pipeline, solidHandle=handle)) return map( lambda d: DauphinUsedSolid( definition=d, invocations=sorted(inv_by_def_name[d.name], key=lambda i: i.solidHandle.handleID), ), sorted(definitions, key=lambda d: d.name), ) def resolve_isPipelineConfigValid(self, graphene_info, pipeline, **kwargs): return validate_pipeline_config( graphene_info, pipeline.to_selector(), kwargs.get('environmentConfigData'), kwargs.get('mode'), ) def resolve_executionPlan(self, graphene_info, pipeline, **kwargs): return get_execution_plan( graphene_info, pipeline.to_selector(), kwargs.get('environmentConfigData'), kwargs.get('mode'), ) def resolve_environmentSchemaOrError(self, graphene_info, **kwargs): return resolve_environment_schema_or_error( graphene_info, kwargs['selector'].to_selector(), kwargs.get('mode')) def resolve_instance(self, graphene_info): return graphene_info.schema.type_named('Instance')( graphene_info.context.instance)
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")) 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): return get_assets(graphene_info) def resolve_assetOrError(self, graphene_info, **kwargs): return get_asset(graphene_info, AssetKey.from_graphql_input(kwargs["assetKey"]))
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 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 DauphinIPipelineSnapshotMixin: # Mixin this class to implement IPipelineSnapshot # # Graphene has some strange properties that make it so that you cannot # implement ABCs nor use properties in an overridable way. So the way # the mixin works is that the target classes have to have a method # get_represented_pipeline() # def get_represented_pipeline(self): raise NotImplementedError() name = dauphin.NonNull(dauphin.String) description = dauphin.String() id = dauphin.NonNull(dauphin.ID) pipeline_snapshot_id = dauphin.NonNull(dauphin.String) dagster_types = dauphin.non_null_list("DagsterType") dagster_type_or_error = dauphin.Field( dauphin.NonNull("DagsterTypeOrError"), dagsterTypeName=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) solids = dauphin.non_null_list("Solid") modes = dauphin.non_null_list("Mode") solid_handles = dauphin.Field(dauphin.non_null_list("SolidHandle"), parentHandleID=dauphin.String()) solid_handle = dauphin.Field( "SolidHandle", handleID=dauphin.Argument(dauphin.NonNull(dauphin.String)), ) tags = dauphin.non_null_list("PipelineTag") runs = dauphin.Field( dauphin.non_null_list("PipelineRun"), cursor=dauphin.String(), limit=dauphin.Int(), ) schedules = dauphin.non_null_list("ScheduleDefinition") parent_snapshot_id = dauphin.String() def resolve_pipeline_snapshot_id(self, _): return self.get_represented_pipeline().identifying_pipeline_snapshot_id def resolve_id(self, _): return self.get_represented_pipeline().identifying_pipeline_snapshot_id def resolve_name(self, _): return self.get_represented_pipeline().name def resolve_description(self, _): return self.get_represented_pipeline().description def resolve_dagster_types(self, _graphene_info): represented_pipeline = self.get_represented_pipeline() return sorted( list( map( lambda dt: to_dauphin_dagster_type( represented_pipeline.pipeline_snapshot, dt.key), [ t for t in represented_pipeline.dagster_type_snaps if t.name ], )), key=lambda dagster_type: dagster_type.name, ) @capture_dauphin_error def resolve_dagster_type_or_error(self, _, **kwargs): type_name = kwargs["dagsterTypeName"] represented_pipeline = self.get_represented_pipeline() if not represented_pipeline.has_dagster_type_named(type_name): from .errors import DauphinDagsterTypeNotFoundError raise UserFacingGraphQLError( DauphinDagsterTypeNotFoundError(dagster_type_name=type_name)) return to_dauphin_dagster_type( represented_pipeline.pipeline_snapshot, represented_pipeline.get_dagster_type_by_name(type_name).key, ) def resolve_solids(self, _graphene_info): represented_pipeline = self.get_represented_pipeline() return build_dauphin_solids( represented_pipeline, represented_pipeline.dep_structure_index, ) def resolve_modes(self, _): represented_pipeline = self.get_represented_pipeline() return [ DauphinMode(represented_pipeline.config_schema_snapshot, mode_def_snap) for mode_def_snap in sorted(represented_pipeline.mode_def_snaps, key=lambda item: item.name) ] def resolve_solid_handle(self, _graphene_info, handleID): return _get_solid_handles( self.get_represented_pipeline()).get(handleID) def resolve_solid_handles(self, _graphene_info, **kwargs): handles = _get_solid_handles(self.get_represented_pipeline()) parentHandleID = kwargs.get("parentHandleID") if parentHandleID == "": handles = { key: handle for key, handle in handles.items() if not handle.parent } elif parentHandleID is not None: handles = { key: handle for key, handle in handles.items() if handle.parent and handle.parent.handleID.to_string() == parentHandleID } return [handles[key] for key in sorted(handles)] def resolve_tags(self, graphene_info): represented_pipeline = self.get_represented_pipeline() return [ graphene_info.schema.type_named("PipelineTag")(key=key, value=value) for key, value in represented_pipeline.pipeline_snapshot.tags.items() ] def resolve_solidSelection(self, _graphene_info): return self.get_represented_pipeline().solid_selection def resolve_runs(self, graphene_info, **kwargs): runs_filter = PipelineRunsFilter( pipeline_name=self.get_represented_pipeline().name) return get_runs(graphene_info, runs_filter, kwargs.get("cursor"), kwargs.get("limit")) def resolve_schedules(self, graphene_info): represented_pipeline = self.get_represented_pipeline() if not isinstance(represented_pipeline, ExternalPipeline): # this is an historical pipeline snapshot, so there are not any associated running # schedules return [] pipeline_selector = represented_pipeline.handle.to_selector() schedules = get_schedule_definitions_for_pipeline( graphene_info, pipeline_selector) return schedules def resolve_parent_snapshot_id(self, _graphene_info): lineage_snapshot = self.get_represented_pipeline( ).pipeline_snapshot.lineage_snapshot if lineage_snapshot: return lineage_snapshot.parent_snapshot_id else: return None
class DauphinRetriesPreviousAttempts(dauphin.InputObjectType): class Meta(object): name = 'RetriesPreviousAttempts' key = dauphin.String() count = dauphin.Int()
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 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.NonNull('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')) 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.get('repositorySelector')), 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): return get_assets(graphene_info) def resolve_assetOrError(self, graphene_info, **kwargs): return get_asset(graphene_info, AssetKey.from_graphql_input(kwargs['assetKey']))