class DauphinConfigType(dauphin.Interface):
class Meta:
name = 'ConfigType'
key = dauphin.NonNull(dauphin.String)
name = dauphin.String()
description = dauphin.String()
inner_types = dauphin.non_null_list('ConfigType')
is_nullable = dauphin.NonNull(dauphin.Boolean)
is_list = dauphin.NonNull(dauphin.Boolean)
is_selector = dauphin.NonNull(dauphin.Boolean)
is_builtin = dauphin.NonNull(
dauphin.Boolean,
description='''
True if the system defines it and it is the same type across pipelines.
Examples include "Int" and "String."''',
)
is_system_generated = dauphin.NonNull(
dauphin.Boolean,
description='''
Dagster generates types for base elements of the config system (e.g. the solids and
context field of the base environment). These types are always present
and are typically not relevant to an end user. This flag allows tool authors to
filter out those types by default.
''',
)
class DauphinOutputDefinition(dauphin.ObjectType):
class Meta:
name = 'OutputDefinition'
solid_definition = dauphin.NonNull('SolidDefinition')
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
type = dauphin.NonNull('RuntimeType')
expectations = dauphin.non_null_list('Expectation')
# outputs - ?
def __init__(self, output_definition, solid_def):
super(DauphinOutputDefinition, self).__init__(
name=output_definition.name,
description=output_definition.description,
solid_definition=solid_def,
)
self._output_definition = check.inst_param(
output_definition, 'output_definition', OutputDefinition
)
def resolve_type(self, _graphene_info):
return to_dauphin_runtime_type(self._output_definition.runtime_type)
def resolve_expectations(self, graphene_info):
if self._output_definition.expectations:
return [
graphene_info.schema.type_named('Expectation')(expectation)
for expectation in self._output_definition.expectations
]
else:
return []
class DauphinType(dauphin.Interface):
class Meta:
name = 'Type'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
type_attributes = dauphin.NonNull('TypeAttributes')
is_dict = dauphin.NonNull(dauphin.Boolean)
is_nullable = dauphin.NonNull(dauphin.Boolean)
is_list = dauphin.NonNull(dauphin.Boolean)
is_selector = dauphin.NonNull(dauphin.Boolean)
inner_types = dauphin.non_null_list('Type')
@classmethod
def to_dauphin_type(cls, info, config_or_runtime_type):
if isinstance(config_or_runtime_type,
ConfigType) and config_or_runtime_type.has_fields:
return info.schema.type_named('CompositeType')(
config_or_runtime_type)
elif isinstance(config_or_runtime_type,
ConfigType) and config_or_runtime_type.is_enum:
return info.schema.type_named('EnumType')(config_or_runtime_type)
else:
return info.schema.type_named('RegularType')(
config_or_runtime_type)
class DauphinInputDefinition(dauphin.ObjectType):
class Meta:
name = 'InputDefinition'
solid_definition = dauphin.NonNull('SolidDefinition')
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
type = dauphin.NonNull('Type')
expectations = dauphin.non_null_list('Expectation')
# inputs - ?
def __init__(self, input_definition, solid_def):
super(DauphinInputDefinition, self).__init__(
name=input_definition.name,
description=input_definition.description,
solid_definition=solid_def,
)
self._input_definition = check.inst_param(input_definition,
'input_definition',
InputDefinition)
def resolve_type(self, info):
return info.schema.type_named('Type').to_dauphin_type(
info, self._input_definition.runtime_type)
def resolve_expectations(self, info):
if self._input_definition.expectations:
return [
info.schema.type_named('Expectation')(
expectation
for expectation in self._input_definition.expectations)
]
else:
return []
class DauphinRuntimeType(dauphin.Interface):
class Meta:
name = 'RuntimeType'
key = dauphin.NonNull(dauphin.String)
name = dauphin.String()
display_name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
is_nullable = dauphin.NonNull(dauphin.Boolean)
is_list = dauphin.NonNull(dauphin.Boolean)
is_builtin = dauphin.NonNull(dauphin.Boolean)
input_schema_type = dauphin.Field(DauphinConfigType)
output_schema_type = dauphin.Field(DauphinConfigType)
inner_types = dauphin.non_null_list('RuntimeType')
class DauphinExpectation(dauphin.ObjectType):
class Meta:
name = 'Expectation'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
def __init__(self, expectation):
check.inst_param(expectation, 'expectation', ExpectationDefinition)
super(DauphinExpectation, self).__init__(
name=expectation.name, description=expectation.description
)
class DauphinConfigTypeField(dauphin.ObjectType):
class Meta:
name = 'ConfigTypeField'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
config_type = dauphin.NonNull('ConfigType')
default_value = dauphin.String()
is_optional = dauphin.NonNull(dauphin.Boolean)
def __init__(self, name, field):
super(DauphinConfigTypeField, self).__init__(
name=name,
description=field.description,
default_value=field.default_value_as_str if field.default_provided else None,
is_optional=field.is_optional,
)
self._field = field
def resolve_config_type(self, _info):
return to_dauphin_config_type(self._field.config_type)
class DauphinExecutionMetadata(dauphin.InputObjectType):
class Meta:
name = 'ExecutionMetadata'
runId = dauphin.String()
tags = dauphin.List(dauphin.NonNull(DauphinExecutionTag))
def to_metadata(self):
tags = {}
if tags:
for tag in self.tags: # pylint: disable=E1133
tags[tag['key']] = tag['value']
return ExecutionMetadata(run_id=self.runId, tags=tags)
class DauphinSolidDefinition(dauphin.ObjectType):
class Meta:
name = 'SolidDefinition'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
metadata = dauphin.non_null_list('SolidMetadataItemDefinition')
input_definitions = dauphin.non_null_list('InputDefinition')
output_definitions = dauphin.non_null_list('OutputDefinition')
config_definition = dauphin.Field('ConfigTypeField')
# solids - ?
def __init__(self, solid_def):
super(DauphinSolidDefinition, self).__init__(
name=solid_def.name, description=solid_def.description
)
self._solid_def = check.inst_param(solid_def, 'solid_def', SolidDefinition)
def resolve_metadata(self, graphene_info):
return [
graphene_info.schema.type_named('SolidMetadataItemDefinition')(
key=item[0], value=item[1]
)
for item in self._solid_def.metadata.items()
]
def resolve_input_definitions(self, graphene_info):
return [
graphene_info.schema.type_named('InputDefinition')(input_definition, self)
for input_definition in self._solid_def.input_defs
]
def resolve_output_definitions(self, graphene_info):
return [
graphene_info.schema.type_named('OutputDefinition')(output_definition, self)
for output_definition in self._solid_def.output_defs
]
def resolve_config_definition(self, graphene_info):
return (
graphene_info.schema.type_named('ConfigTypeField')(
name="config", field=self._solid_def.config_field
)
if self._solid_def.config_field
else None
)
class DauphinResource(dauphin.ObjectType):
class Meta:
name = 'Resource'
def __init__(self, resource_name, resource):
self.name = check.str_param(resource_name, 'resource_name')
self._resource = check.inst_param(resource, 'resource',
ResourceDefinition)
self.description = resource.description
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
config = dauphin.Field('ConfigTypeField')
def resolve_config(self, info):
return (info.schema.type_named('ConfigTypeField')(
name="config", field=self._resource.config_field)
if self._resource.config_field else None)
class DauphinPipelineContext(dauphin.ObjectType):
class Meta:
name = 'PipelineContext'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
config = dauphin.Field('ConfigTypeField')
resources = dauphin.non_null_list('Resource')
def __init__(self, name, context):
super(DauphinPipelineContext, self).__init__(name=name, description=context.description)
self._context = check.inst_param(context, 'context', PipelineContextDefinition)
def resolve_config(self, graphene_info):
return (
graphene_info.schema.type_named('ConfigTypeField')(
name="config", field=self._context.config_field
)
if self._context.config_field
else None
)
def resolve_resources(self, _graphene_info):
return [DauphinResource(*item) for item in self._context.resources.items()]
class DauphinPipeline(dauphin.ObjectType):
class Meta:
name = 'Pipeline'
name = dauphin.NonNull(dauphin.String)
description = dauphin.String()
solids = dauphin.non_null_list('Solid')
contexts = dauphin.non_null_list('PipelineContext')
environment_type = dauphin.NonNull('ConfigType')
config_types = dauphin.non_null_list('ConfigType')
runtime_types = dauphin.non_null_list('RuntimeType')
runs = dauphin.non_null_list('PipelineRun')
def __init__(self, pipeline):
super(DauphinPipeline, self).__init__(name=pipeline.name, description=pipeline.description)
self._pipeline = check.inst_param(pipeline, 'pipeline', PipelineDefinition)
def resolve_solids(self, graphene_info):
return [
graphene_info.schema.type_named('Solid')(
solid,
self._pipeline.dependency_structure.deps_of_solid_with_input(solid.name),
self._pipeline.dependency_structure.depended_by_of_solid(solid.name),
)
for solid in self._pipeline.solids
]
def resolve_contexts(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineContext')(name=name, context=context)
for name, context in self._pipeline.context_definitions.items()
]
def resolve_environment_type(self, _graphene_info):
return to_dauphin_config_type(self._pipeline.environment_type)
def resolve_config_types(self, _graphene_info):
return sorted(
list(map(to_dauphin_config_type, self._pipeline.all_config_types())),
key=lambda config_type: config_type.key,
)
def resolve_runtime_types(self, _graphene_info):
return sorted(
list(
map(
to_dauphin_runtime_type,
[t for t in self._pipeline.all_runtime_types() if t.name],
)
),
key=lambda config_type: config_type.name,
)
def resolve_runs(self, graphene_info):
return [
graphene_info.schema.type_named('PipelineRun')(r)
for r in graphene_info.context.pipeline_runs.all_runs_for_pipeline(self._pipeline.name)
]
def get_dagster_pipeline(self):
return self._pipeline
def get_type(self, _graphene_info, typeName):
if self._pipeline.has_config_type(typeName):
return to_dauphin_config_type(self._pipeline.config_type_named(typeName))
elif self._pipeline.has_runtime_type(typeName):
return to_dauphin_runtime_type(self._pipeline.runtime_type_named(typeName))
else:
check.failed('Not a config type or runtime type')
class DauphinError(dauphin.Interface):
class Meta:
name = 'Error'
message = dauphin.String(required=True)
stack = dauphin.non_null_list(dauphin.String)
class DauphinEnumConfigValue(dauphin.ObjectType):
class Meta:
name = 'EnumConfigValue'
value = dauphin.NonNull(dauphin.String)
description = dauphin.String()
