Differential D6164 Diff 30546 python_modules/dagster-graphql/dagster_graphql/schema/errors.py

Changeset View

Standalone View

python_modules/dagster-graphql/dagster_graphql/schema/errors.py

				import graphene
	from dagster import check			from dagster import check
	from dagster.config.errors import (			from dagster.core.definitions.events import AssetKey
	EvaluationError,
	FieldNotDefinedErrorData,
	FieldsNotDefinedErrorData,
	MissingFieldErrorData,
	MissingFieldsErrorData,
	RuntimeMismatchErrorData,
	SelectorTypeErrorData,
	)
	from dagster.config.stack import EvaluationStackListItemEntry, EvaluationStackPathEntry
	from dagster.core.host_representation import RepresentedPipeline
	from dagster.core.snap import ConfigSchemaSnapshot
	from dagster.utils.error import SerializableErrorInfo			from dagster.utils.error import SerializableErrorInfo
	from dagster_graphql import dauphin

	from ..implementation.fetch_runs import get_runs, get_runs_count
	from ..implementation.utils import PipelineSelector			from ..implementation.utils import PipelineSelector
	from .config_types import DauphinConfigTypeField			from .util import non_null_list


				class GrapheneError(graphene.Interface):
				message = graphene.String(required=True)
				maxAuthorUnsubmitted Done Inline Actions this moved off `dauphin` max: this moved off `dauphin`

	class DauphinError(dauphin.Interface):
	class Meta:			class Meta:
	name = "Error"			name = "Error"

	message = dauphin.String(required=True)


	class DauphinPythonError(dauphin.ObjectType):			class GraphenePythonError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PythonError"			name = "PythonError"
	interfaces = (DauphinError,)

	className = dauphin.Field(dauphin.String)			className = graphene.Field(graphene.String)
	stack = dauphin.non_null_list(dauphin.String)			stack = non_null_list(graphene.String)
	cause = dauphin.Field("PythonError")			cause = graphene.Field(lambda: GraphenePythonError)

	def __init__(self, error_info):			def __init__(self, error_info):
	super(DauphinPythonError, self).__init__()			super().__init__()
				maxAuthorUnsubmitted Done Inline Actions python 3 `super` throughout max: python 3 `super` throughout
	check.inst_param(error_info, "error_info", SerializableErrorInfo)			check.inst_param(error_info, "error_info", SerializableErrorInfo)
	self.message = error_info.message			self.message = error_info.message
	self.stack = error_info.stack			self.stack = error_info.stack
	self.cause = error_info.cause			self.cause = error_info.cause
	self.className = error_info.cls_name			self.className = error_info.cls_name


	class DauphinSchedulerNotDefinedError(dauphin.ObjectType):			class GrapheneSchedulerNotDefinedError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "SchedulerNotDefinedError"			name = "SchedulerNotDefinedError"
	interfaces = (DauphinError,)

	def __init__(self):			def __init__(self):
	super(DauphinSchedulerNotDefinedError, self).__init__()			super().__init__()
	self.message = "Scheduler is not defined for the currently loaded repository."			self.message = "Scheduler is not defined for the currently loaded repository."


	class DauphinPipelineSnapshotNotFoundError(dauphin.ObjectType):			class GraphenePipelineSnapshotNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PipelineSnapshotNotFoundError"			name = "PipelineSnapshotNotFoundError"
	interfaces = (DauphinError,)

	snapshot_id = dauphin.NonNull(dauphin.String)			snapshot_id = graphene.NonNull(graphene.String)

	def __init__(self, snapshot_id):			def __init__(self, snapshot_id):
	super(DauphinPipelineSnapshotNotFoundError, self).__init__()			super().__init__()
	self.snapshot_id = check.str_param(snapshot_id, "snapshot_id")			self.snapshot_id = check.str_param(snapshot_id, "snapshot_id")
	self.message = (			self.message = f"Pipeline snapshot {snapshot_id} is not present in the current instance."
	"Pipeline snapshot {snapshot_id} is not present in the current instance."
	).format(snapshot_id=snapshot_id)


	class DauphinReloadNotSupported(dauphin.ObjectType):			class GrapheneReloadNotSupported(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "ReloadNotSupported"			name = "ReloadNotSupported"
	interfaces = (DauphinError,)

	def __init__(self, location_name):			def __init__(self, location_name):
	self.message = "Location {location_name} does not support reloading.".format(			super().__init__()
	location_name=location_name			self.message = f"Location {location_name} does not support reloading."
	)


	class DauphinRepositoryLocationNotFound(dauphin.ObjectType):			class GrapheneRepositoryLocationNotFound(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "RepositoryLocationNotFound"			name = "RepositoryLocationNotFound"
	interfaces = (DauphinError,)

	def __init__(self, location_name):			def __init__(self, location_name):
	self.message = "Location {location_name} does not exist.".format(			super().__init__()
	location_name=location_name			self.message = f"Location {location_name} does not exist."
	)


	class DauphinPipelineNotFoundError(dauphin.ObjectType):			class GraphenePipelineNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PipelineNotFoundError"			name = "PipelineNotFoundError"
	interfaces = (DauphinError,)

	pipeline_name = dauphin.NonNull(dauphin.String)			pipeline_name = graphene.NonNull(graphene.String)
	repository_name = dauphin.NonNull(dauphin.String)			repository_name = graphene.NonNull(graphene.String)
	repository_location_name = dauphin.NonNull(dauphin.String)			repository_location_name = graphene.NonNull(graphene.String)

	def __init__(self, selector):			def __init__(self, selector):
	super(DauphinPipelineNotFoundError, self).__init__()			super().__init__()
	check.inst_param(selector, "selector", PipelineSelector)			check.inst_param(selector, "selector", PipelineSelector)
	self.pipeline_name = selector.pipeline_name			self.pipeline_name = selector.pipeline_name
	self.repository_name = selector.repository_name			self.repository_name = selector.repository_name
	self.repository_location_name = selector.location_name			self.repository_location_name = selector.location_name
	self.message = "Could not find Pipeline {selector.location_name}.{selector.repository_name}.{selector.pipeline_name}".format(			self.message = (
	selector=selector			"Could not find Pipeline "
				f"{selector.location_name}.{selector.repository_name}.{selector.pipeline_name}"
				maxAuthorUnsubmitted Done Inline Actions more format strings max: more format strings
	)			)


	class DauphinPipelineRunNotFoundError(dauphin.ObjectType):			class GraphenePipelineRunNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PipelineRunNotFoundError"			name = "PipelineRunNotFoundError"
	interfaces = (DauphinError,)

	run_id = dauphin.NonNull(dauphin.String)			run_id = graphene.NonNull(graphene.String)

	def __init__(self, run_id):			def __init__(self, run_id):
	super(DauphinPipelineRunNotFoundError, self).__init__()			super().__init__()
	self.run_id = check.str_param(run_id, "run_id")			self.run_id = check.str_param(run_id, "run_id")
	self.message = "Pipeline run {run_id} could not be found.".format(run_id=run_id)			self.message = f"Pipeline run {run_id} could not be found."


	class DauphinInvalidPipelineRunsFilterError(dauphin.ObjectType):			class GrapheneInvalidPipelineRunsFilterError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "InvalidPipelineRunsFilterError"			name = "InvalidPipelineRunsFilterError"
	interfaces = (DauphinError,)

	def __init__(self, message):			def __init__(self, message):
	super(DauphinInvalidPipelineRunsFilterError, self).__init__()			super().__init__()
	self.message = check.str_param(message, "message")			self.message = check.str_param(message, "message")


	class DauphinRunGroupNotFoundError(dauphin.ObjectType):			class GrapheneRunGroupNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "RunGroupNotFoundError"			name = "RunGroupNotFoundError"
	interfaces = (DauphinError,)

	run_id = dauphin.NonNull(dauphin.String)			run_id = graphene.NonNull(graphene.String)

	def __init__(self, run_id):			def __init__(self, run_id):
	super(DauphinRunGroupNotFoundError, self).__init__()			super().__init__()
	self.run_id = check.str_param(run_id, "run_id")			self.run_id = check.str_param(run_id, "run_id")
	self.message = "Run group of run {run_id} could not be found.".format(run_id=run_id)			self.message = f"Run group of run {run_id} could not be found."


	class DauphinInvalidSubsetError(dauphin.ObjectType):			class GraphenePresetNotFoundError(graphene.ObjectType):
	class Meta:
	name = "InvalidSubsetError"
	interfaces = (DauphinError,)

	pipeline = dauphin.Field(dauphin.NonNull("Pipeline"))

	def __init__(self, message, pipeline):
	super(DauphinInvalidSubsetError, self).__init__()
	self.message = check.str_param(message, "message")
	self.pipeline = pipeline


	class DauphinPresetNotFoundError(dauphin.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PresetNotFoundError"			name = "PresetNotFoundError"
	interfaces = (DauphinError,)

	preset = dauphin.NonNull(dauphin.String)			preset = graphene.NonNull(graphene.String)

	def __init__(self, preset, selector):			def __init__(self, preset, selector):
				super().__init__()
	self.preset = check.str_param(preset, "preset")			self.preset = check.str_param(preset, "preset")
	self.message = "Preset {preset} not found in pipeline {pipeline}.".format(			self.message = f"Preset {preset} not found in pipeline {selector.pipeline_name}."
	preset=preset, pipeline=selector.pipeline_name
	)


	class DauphinConflictingExecutionParamsError(dauphin.ObjectType):			class GrapheneConflictingExecutionParamsError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "ConflictingExecutionParamsError"			name = "ConflictingExecutionParamsError"
	interfaces = (DauphinError,)

	def __init__(self, conflicting_param):			def __init__(self, conflicting_param):
	self.message = "Invalid ExecutionParams. Cannot define {conflicting_param} when using a preset.".format(			super().__init__()
	conflicting_param=conflicting_param			self.message = (
				f"Invalid ExecutionParams. Cannot define {conflicting_param} when using a preset."
	)			)


	class DauphinModeNotFoundError(dauphin.ObjectType):			class GrapheneModeNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "ModeNotFoundError"			name = "ModeNotFoundError"
	interfaces = (DauphinError,)

	mode = dauphin.NonNull(dauphin.String)			mode = graphene.NonNull(graphene.String)

	def __init__(self, mode, selector):			def __init__(self, mode, selector):
				super().__init__()
	self.mode = check.str_param(mode, "mode")			self.mode = check.str_param(mode, "mode")
	self.message = "Mode {mode} not found in pipeline {pipeline}.".format(			self.message = f"Mode {mode} not found in pipeline {selector.pipeline_name}."
	mode=mode, pipeline=selector.pipeline_name
	)


	class DauphinPipelineConfigValidationValid(dauphin.ObjectType):
	class Meta:
	name = "PipelineConfigValidationValid"

	pipeline_name = dauphin.NonNull(dauphin.String)


	class DauphinPipelineConfigValidationInvalid(dauphin.ObjectType):
	class Meta:
	name = "PipelineConfigValidationInvalid"

	pipeline_name = dauphin.NonNull(dauphin.String)
	errors = dauphin.non_null_list("PipelineConfigValidationError")

	@staticmethod
	def for_validation_errors(represented_pipeline, errors):
	check.inst_param(represented_pipeline, "represented_pipeline", RepresentedPipeline)
	check.list_param(errors, "errors", of_type=EvaluationError)
	return DauphinPipelineConfigValidationInvalid(
	pipeline_name=represented_pipeline.name,
	errors=[
	DauphinPipelineConfigValidationError.from_dagster_error(
	represented_pipeline.config_schema_snapshot, err
	)
	for err in errors
	],
	)


	class DauphinPipelineConfigValidationResult(dauphin.Union):
	class Meta:
	name = "PipelineConfigValidationResult"
	types = (
	DauphinInvalidSubsetError,
	DauphinPipelineConfigValidationValid,
	DauphinPipelineConfigValidationInvalid,
	DauphinPipelineNotFoundError,
	DauphinPythonError,
	)


	class DauphinPipelineConfigValidationError(dauphin.Interface):
	class Meta:
	name = "PipelineConfigValidationError"

	message = dauphin.NonNull(dauphin.String)
	path = dauphin.non_null_list(dauphin.String)
	stack = dauphin.NonNull("EvaluationStack")
	reason = dauphin.NonNull("EvaluationErrorReason")

	@staticmethod
	def from_dagster_error(config_schema_snapshot, error):
	check.inst_param(config_schema_snapshot, "config_schema_snapshot", ConfigSchemaSnapshot)
	check.inst_param(error, "error", EvaluationError)

	if isinstance(error.error_data, RuntimeMismatchErrorData):
	return DauphinRuntimeMismatchConfigError(
	message=error.message,
	path=[], # TODO: remove
	stack=DauphinEvaluationStack(config_schema_snapshot, error.stack),
	reason=error.reason,
	value_rep=error.error_data.value_rep,
	)
	elif isinstance(error.error_data, MissingFieldErrorData):
	return DauphinMissingFieldConfigError(
	message=error.message,
	path=[], # TODO: remove
	stack=DauphinEvaluationStack(config_schema_snapshot, error.stack),
	reason=error.reason,
	field=DauphinConfigTypeField(
	config_schema_snapshot=config_schema_snapshot,
	field_snap=error.error_data.field_snap,
	),
	)
	elif isinstance(error.error_data, MissingFieldsErrorData):
	return DauphinMissingFieldsConfigError(
	message=error.message,
	path=[], # TODO: remove
	stack=DauphinEvaluationStack(config_schema_snapshot, error.stack),
	reason=error.reason,
	fields=[
	DauphinConfigTypeField(
	config_schema_snapshot=config_schema_snapshot, field_snap=field_snap,
	)
	for field_snap in error.error_data.field_snaps
	],
	)

	elif isinstance(error.error_data, FieldNotDefinedErrorData):
	return DauphinFieldNotDefinedConfigError(
	message=error.message,
	path=[], # TODO: remove
	stack=DauphinEvaluationStack(config_schema_snapshot, error.stack),
	reason=error.reason,
	field_name=error.error_data.field_name,
	)
	elif isinstance(error.error_data, FieldsNotDefinedErrorData):
	return DauphinFieldsNotDefinedConfigError(
	message=error.message,
	path=[], # TODO: remove
	stack=DauphinEvaluationStack(config_schema_snapshot, error.stack),
	reason=error.reason,
	field_names=error.error_data.field_names,
	)
	elif isinstance(error.error_data, SelectorTypeErrorData):
	return DauphinSelectorTypeConfigError(
	message=error.message,
	path=[], # TODO: remove
	stack=DauphinEvaluationStack(config_schema_snapshot, error.stack),
	reason=error.reason,
	incoming_fields=error.error_data.incoming_fields,
	)
	else:
	check.failed(
	"Error type not supported {error_data}".format(error_data=repr(error.error_data))
	)


	class DauphinRuntimeMismatchConfigError(dauphin.ObjectType):
	class Meta:
	name = "RuntimeMismatchConfigError"
	interfaces = (DauphinPipelineConfigValidationError,)

	value_rep = dauphin.Field(dauphin.String)


	class DauphinMissingFieldConfigError(dauphin.ObjectType):
	class Meta:
	name = "MissingFieldConfigError"
	interfaces = (DauphinPipelineConfigValidationError,)

	field = dauphin.NonNull("ConfigTypeField")


	class DauphinMissingFieldsConfigError(dauphin.ObjectType):
	class Meta:
	name = "MissingFieldsConfigError"
	interfaces = (DauphinPipelineConfigValidationError,)

	fields = dauphin.non_null_list("ConfigTypeField")


	class DauphinFieldNotDefinedConfigError(dauphin.ObjectType):
	class Meta:
	name = "FieldNotDefinedConfigError"
	interfaces = (DauphinPipelineConfigValidationError,)

	field_name = dauphin.NonNull(dauphin.String)


	class DauphinFieldsNotDefinedConfigError(dauphin.ObjectType):
	class Meta:
	name = "FieldsNotDefinedConfigError"
	interfaces = (DauphinPipelineConfigValidationError,)

	field_names = dauphin.non_null_list(dauphin.String)


	class DauphinSelectorTypeConfigError(dauphin.ObjectType):
	class Meta:
	name = "SelectorTypeConfigError"
	interfaces = (DauphinPipelineConfigValidationError,)

	incoming_fields = dauphin.non_null_list(dauphin.String)


	class DauphinEvaluationErrorReason(dauphin.Enum):
	class Meta:
	name = "EvaluationErrorReason"

	RUNTIME_TYPE_MISMATCH = "RUNTIME_TYPE_MISMATCH"
	MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD"
	MISSING_REQUIRED_FIELDS = "MISSING_REQUIRED_FIELDS"
	FIELD_NOT_DEFINED = "FIELD_NOT_DEFINED"
	FIELDS_NOT_DEFINED = "FIELDS_NOT_DEFINED"
	SELECTOR_FIELD_ERROR = "SELECTOR_FIELD_ERROR"


	class DauphinEvaluationStackListItemEntry(dauphin.ObjectType):
	class Meta:
	name = "EvaluationStackListItemEntry"

	def __init__(self, list_index):
	super(DauphinEvaluationStackListItemEntry, self).__init__()
	self._list_index = list_index

	list_index = dauphin.NonNull(dauphin.Int)

	def resolve_list_index(self, _info):
	return self._list_index


	class DauphinEvaluationStackPathEntry(dauphin.ObjectType):
	class Meta:
	name = "EvaluationStackPathEntry"

	def __init__(self, field_name):
	self._field_name = check.str_param(field_name, "field_name")
	super(DauphinEvaluationStackPathEntry, self).__init__()

	field_name = dauphin.NonNull(dauphin.String)			class GrapheneInvalidStepError(graphene.ObjectType):
				invalid_step_key = graphene.NonNull(graphene.String)

	def resolve_field_name(self, _info):
	return self._field_name


	class DauphinEvaluationStackEntry(dauphin.Union):
	class Meta:
	name = "EvaluationStackEntry"
	types = (DauphinEvaluationStackListItemEntry, DauphinEvaluationStackPathEntry)

	@staticmethod
	def from_native_entry(entry):
	if isinstance(entry, EvaluationStackPathEntry):
	return DauphinEvaluationStackPathEntry(field_name=entry.field_name)
	elif isinstance(entry, EvaluationStackListItemEntry):
	return DauphinEvaluationStackListItemEntry(list_index=entry.list_index)
	else:
	check.failed("Unsupported stack entry type {entry}".format(entry=entry))


	class DauphinEvaluationStack(dauphin.ObjectType):
	def __init__(self, config_schema_snapshot, stack):
	self._config_schema_snapshot = check.inst_param(
	config_schema_snapshot, "config_schema_snapshot", ConfigSchemaSnapshot
	)
	self._stack = stack
	super(DauphinEvaluationStack, self).__init__()

	class Meta:
	name = "EvaluationStack"

	entries = dauphin.non_null_list("EvaluationStackEntry")

	def resolve_entries(self, _):
	return map(DauphinEvaluationStackEntry.from_native_entry, self._stack.entries)


	class DauphinExecutionPlanOrError(dauphin.Union):
	class Meta:
	name = "ExecutionPlanOrError"
	types = (
	"ExecutionPlan",
	DauphinPipelineConfigValidationInvalid,
	DauphinPipelineNotFoundError,
	DauphinInvalidSubsetError,
	DauphinPythonError,
	)


	class DauphinLaunchPipelineRunSuccess(dauphin.ObjectType):
	class Meta:
	name = "LaunchPipelineRunSuccess"

	run = dauphin.Field(dauphin.NonNull("PipelineRun"))


	class DauphinInvalidStepError(dauphin.ObjectType):
	class Meta:			class Meta:
	name = "InvalidStepError"			name = "InvalidStepError"

	invalid_step_key = dauphin.NonNull(dauphin.String)

				class GrapheneInvalidOutputError(graphene.ObjectType):
				step_key = graphene.NonNull(graphene.String)
				invalid_output_name = graphene.NonNull(graphene.String)

	class DauphinInvalidOutputError(dauphin.ObjectType):
	class Meta:			class Meta:
	name = "InvalidOutputError"			name = "InvalidOutputError"

	step_key = dauphin.NonNull(dauphin.String)
	invalid_output_name = dauphin.NonNull(dauphin.String)

				class GraphenePipelineRunConflict(graphene.ObjectType):
	class DauphinPipelineRunConflict(dauphin.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PipelineRunConflict"			name = "PipelineRunConflict"
	interfaces = (DauphinError,)


	create_execution_params_error_types = (			create_execution_params_error_types = (
	DauphinPresetNotFoundError,			GraphenePresetNotFoundError,
	DauphinConflictingExecutionParamsError,			GrapheneConflictingExecutionParamsError,
	)			)

	pipeline_execution_error_types = (
	DauphinInvalidStepError,
	DauphinInvalidOutputError,
	DauphinPipelineConfigValidationInvalid,
	DauphinPipelineNotFoundError,
	DauphinPipelineRunConflict,
	DauphinPythonError,
	) + create_execution_params_error_types


	launch_pipeline_run_result_types = (DauphinLaunchPipelineRunSuccess,)


	class DauphinLaunchPipelineExecutionResult(dauphin.Union):
	class Meta:
	name = "LaunchPipelineExecutionResult"
	types = launch_pipeline_run_result_types + pipeline_execution_error_types


	class DauphinLaunchPipelineReexecutionResult(dauphin.Union):
	class Meta:
	name = "LaunchPipelineReexecutionResult"
	types = launch_pipeline_run_result_types + pipeline_execution_error_types


	class DauphinConfigTypeNotFoundError(dauphin.ObjectType):			class GrapheneDagsterTypeNotFoundError(graphene.ObjectType):
	class Meta:
	name = "ConfigTypeNotFoundError"
	interfaces = (DauphinError,)

	pipeline = dauphin.NonNull("Pipeline")
	config_type_name = dauphin.NonNull(dauphin.String)


	class DauphinDagsterTypeNotFoundError(dauphin.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "DagsterTypeNotFoundError"			name = "DagsterTypeNotFoundError"
	interfaces = (DauphinError,)

	dagster_type_name = dauphin.NonNull(dauphin.String)

				dagster_type_name = graphene.NonNull(graphene.String)
	class DauphinConfigTypeOrError(dauphin.Union):
	class Meta:
	name = "ConfigTypeOrError"
	types = (
	"EnumConfigType",
	"CompositeConfigType",
	"RegularConfigType",
	DauphinPipelineNotFoundError,
	DauphinConfigTypeNotFoundError,
	DauphinPythonError,
	)


	class DauphinDagsterTypeOrError(dauphin.Union):			class GrapheneScheduleNotFoundError(graphene.ObjectType):
	class Meta:
	name = "DagsterTypeOrError"
	types = (
	"RegularDagsterType",
	DauphinPipelineNotFoundError,
	DauphinDagsterTypeNotFoundError,
	DauphinPythonError,
	)


	class DauphinPipelineRunOrError(dauphin.Union):
	class Meta:
	name = "PipelineRunOrError"
	types = ("PipelineRun", DauphinPipelineRunNotFoundError, DauphinPythonError)


	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 DauphinPipelineRunsOrError(dauphin.Union):
	class Meta:
	name = "PipelineRunsOrError"
	types = (DauphinPipelineRuns, DauphinInvalidPipelineRunsFilterError, DauphinPythonError)


	class DauphinRunGroupOrError(dauphin.Union):
	class Meta:
	name = "RunGroupOrError"
	types = ("RunGroup", DauphinRunGroupNotFoundError, DauphinPythonError)


	class DauphinRunGroupsOrError(dauphin.ObjectType):
	class Meta:
	name = "RunGroupsOrError"
	types = ("RunGroups", DauphinPythonError)

	results = dauphin.non_null_list("RunGroup")


	class DauphinScheduleNotFoundError(dauphin.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "ScheduleNotFoundError"			name = "ScheduleNotFoundError"
	interfaces = (DauphinError,)

	schedule_name = dauphin.NonNull(dauphin.String)			schedule_name = graphene.NonNull(graphene.String)

	def __init__(self, schedule_name):			def __init__(self, schedule_name):
	super(DauphinScheduleNotFoundError, self).__init__()			super().__init__()
	self.schedule_name = check.str_param(schedule_name, "schedule_name")			self.schedule_name = check.str_param(schedule_name, "schedule_name")
	self.message = "Schedule {schedule_name} could not be found.".format(			self.message = f"Schedule {self.schedule_name} could not be found."
	schedule_name=self.schedule_name
	)


	class DauphinSensorNotFoundError(dauphin.ObjectType):			class GrapheneSensorNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "SensorNotFoundError"			name = "SensorNotFoundError"
	interfaces = (DauphinError,)

	sensor_name = dauphin.NonNull(dauphin.String)			sensor_name = graphene.NonNull(graphene.String)

	def __init__(self, sensor_name):			def __init__(self, sensor_name):
	super(DauphinSensorNotFoundError, self).__init__()			super().__init__()
	self.name = check.str_param(sensor_name, "sensor_name")			self.name = check.str_param(sensor_name, "sensor_name")
	self.message = f"Could not find `{sensor_name}` in the currently loaded repository."			self.message = f"Could not find `{sensor_name}` in the currently loaded repository."


	class DauphinJobNotFoundError(dauphin.ObjectType):			class GrapheneJobNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
	name = "JobNotFoundError"			name = "JobNotFoundError"
	interfaces = (DauphinError,)			interfaces = (GrapheneError,)

	def __init__(self, job_name):			def __init__(self, job_name):
	super(DauphinJobNotFoundError, self).__init__()			super().__init__()
	self.name = check.str_param(job_name, "job_name")			self.name = check.str_param(job_name, "job_name")
	self.message = f"Job {job_name} is not present in the currently loaded repository."			self.message = f"Job {job_name} is not present in the currently loaded repository."


	class DauphinPartitionSetNotFoundError(dauphin.ObjectType):			class GraphenePartitionSetNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "PartitionSetNotFoundError"			name = "PartitionSetNotFoundError"
	interfaces = (DauphinError,)

	partition_set_name = dauphin.NonNull(dauphin.String)			partition_set_name = graphene.NonNull(graphene.String)

	def __init__(self, partition_set_name):			def __init__(self, partition_set_name):
	super(DauphinPartitionSetNotFoundError, self).__init__()			super().__init__()
	self.partition_set_name = check.str_param(partition_set_name, "partition_set_name")			self.partition_set_name = check.str_param(partition_set_name, "partition_set_name")
	self.message = "Partition set {partition_set_name} could not be found.".format(			self.message = f"Partition set {self.partition_set_name} could not be found."
	partition_set_name=self.partition_set_name
	)


	class DauphinPartitionBackfillSuccess(dauphin.ObjectType):
	class Meta:
	name = "PartitionBackfillSuccess"

	backfill_id = dauphin.NonNull(dauphin.String)
	launched_run_ids = dauphin.non_null_list(dauphin.String)


	class DauphinPartitionBackfillResult(dauphin.Union):
	class Meta:
	name = "PartitionBackfillResult"
	types = (
	DauphinPartitionBackfillSuccess,
	DauphinPartitionSetNotFoundError,
	) + pipeline_execution_error_types


	class DauphinRepositoriesOrError(dauphin.Union):
	class Meta:
	name = "RepositoriesOrError"
	types = ("RepositoryConnection", DauphinPythonError)


	class RepositoryLocationsOrError(dauphin.Union):
	class Meta:
	name = "RepositoryLocationsOrError"
	types = ("RepositoryLocationConnection", DauphinPythonError)


	class DauphinRepositoryNotFoundError(dauphin.ObjectType):			class GrapheneRepositoryNotFoundError(graphene.ObjectType):
	class Meta:			class Meta:
				interfaces = (GrapheneError,)
	name = "RepositoryNotFoundError"			name = "RepositoryNotFoundError"
	interfaces = (DauphinError,)

	repository_name = dauphin.NonNull(dauphin.String)			repository_name = graphene.NonNull(graphene.String)
	repository_location_name = dauphin.NonNull(dauphin.String)			repository_location_name = graphene.NonNull(graphene.String)

	def __init__(self, repository_location_name, repository_name):			def __init__(self, repository_location_name, repository_name):
	super(DauphinRepositoryNotFoundError, self).__init__()			super().__init__()
	self.repository_name = check.str_param(repository_name, "repository_name")			self.repository_name = check.str_param(repository_name, "repository_name")
	self.repository_location_name = check.str_param(			self.repository_location_name = check.str_param(
	repository_location_name, "repository_location_name"			repository_location_name, "repository_location_name"
	)			)
	self.message = "Could not find Repository {repository_location_name}.{repository_name}".format(			self.message = f"Could not find Repository {repository_location_name}.{repository_name}"
	repository_name=repository_name, repository_location_name=repository_location_name
	)


	class DauphinRepositoryOrError(dauphin.Union):			class GrapheneAssetsNotSupportedError(graphene.ObjectType):
	class Meta:			class Meta:
	name = "RepositoryOrError"			interfaces = (GrapheneError,)
	types = (DauphinPythonError, "Repository", DauphinRepositoryNotFoundError)			name = "AssetsNotSupportedError"


				class GrapheneAssetNotFoundError(graphene.ObjectType):
				class Meta:
				interfaces = (GrapheneError,)
				name = "AssetNotFoundError"

				def __init__(self, asset_key):
				super().__init__()
				self.asset_key = check.inst_param(asset_key, "asset_key", AssetKey)
				self.message = f"Asset key {asset_key.to_string()} not found."


				types = [
				GrapheneAssetNotFoundError,
				GrapheneAssetsNotSupportedError,
				GrapheneConflictingExecutionParamsError,
				GrapheneDagsterTypeNotFoundError,
				GrapheneError,
				GrapheneInvalidOutputError,
				GrapheneInvalidPipelineRunsFilterError,
				GrapheneInvalidStepError,
				GrapheneModeNotFoundError,
				GraphenePartitionSetNotFoundError,
				GraphenePipelineNotFoundError,
				GraphenePipelineRunConflict,
				GraphenePipelineRunNotFoundError,
				GraphenePipelineSnapshotNotFoundError,
				GraphenePresetNotFoundError,
				GraphenePythonError,
				GrapheneReloadNotSupported,
				GrapheneRepositoryLocationNotFound,
				GrapheneRepositoryNotFoundError,
				GrapheneRunGroupNotFoundError,
				GrapheneScheduleNotFoundError,
				GrapheneSchedulerNotDefinedError,
				GrapheneSensorNotFoundError,
				]