def test_handle_to_from_string():
handle = NodeHandle("baz", NodeHandle("bar", NodeHandle("foo", None)))
assert handle.to_string() == "foo.bar.baz"
assert NodeHandle.from_string(handle.to_string()) == handle
handle = NodeHandle("foo", None)
assert handle.to_string() == "foo"
assert NodeHandle.from_string(handle.to_string()) == handle
def parse_from_key(
string: str,
) -> Union["StepHandle", "ResolvedFromDynamicStepHandle",
"UnresolvedStepHandle"]:
unresolved_match = re.match(r"(.*)\[\?\]", string)
if unresolved_match:
return UnresolvedStepHandle(
NodeHandle.from_string(unresolved_match.group(1)))
resolved_match = re.match(r"(.*)\[(.*)\]", string)
if resolved_match:
return ResolvedFromDynamicStepHandle(
NodeHandle.from_string(resolved_match.group(1)),
resolved_match.group(2))
return StepHandle(NodeHandle.from_string(string))
def core_execute_in_process(
node: NodeDefinition,
run_config: Dict[str, Any],
ephemeral_pipeline: PipelineDefinition,
instance: Optional[DagsterInstance],
output_capturing_enabled: bool,
):
pipeline_def = ephemeral_pipeline
mode_def = pipeline_def.get_mode_definition()
pipeline = InMemoryPipeline(pipeline_def)
execution_plan = create_execution_plan(pipeline,
run_config=run_config,
mode=mode_def.name)
recorder: Dict[StepOutputHandle, Any] = {}
with ephemeral_instance_if_missing(instance) as execute_instance:
pipeline_run = execute_instance.create_run_for_pipeline(
pipeline_def=pipeline_def,
run_config=run_config,
mode=mode_def.name,
)
_execute_run_iterable = ExecuteRunWithPlanIterable(
execution_plan=execution_plan,
iterator=pipeline_execution_iterator,
execution_context_manager=PlanOrchestrationContextManager(
context_event_generator=orchestration_context_event_generator,
pipeline=pipeline,
execution_plan=execution_plan,
pipeline_run=pipeline_run,
instance=execute_instance,
run_config=run_config,
executor_defs=None,
output_capture=recorder if output_capturing_enabled else None,
),
)
event_list = list(_execute_run_iterable)
top_level_node_handle = NodeHandle.from_string(node.name)
if isinstance(node, GraphDefinition) and node == ephemeral_pipeline.graph:
event_list_for_top_lvl_node = event_list
handle = None
return InProcessGraphResult(node, handle, event_list_for_top_lvl_node,
recorder)
else:
event_list_for_top_lvl_node = [
event for event in event_list if event.solid_handle
and event.solid_handle.is_or_descends_from(top_level_node_handle)
]
handle = NodeHandle(node.name, None)
if isinstance(node, SolidDefinition):
return InProcessSolidResult(node, handle,
event_list_for_top_lvl_node, recorder)
elif isinstance(node, GraphDefinition):
return InProcessGraphResult(node, handle,
event_list_for_top_lvl_node, recorder)
check.failed(f"Unexpected node type {node}")