code: def generate_resolved_info(
      mlmd_handle_like: mlmd_cm.HandleLike,
      node: node_proto_view.NodeProtoView,
      pipeline: pipeline_pb2.Pipeline,
      skip_errors: Iterable[Type[exceptions.InputResolutionError]] = (),
  ) -> ResolvedInfo:
      """Returns a `ResolvedInfo` object for executing the node or `None` to skip.
  
      Args:
        mlmd_handle_like: An instance of mlmd handle which connect one MLMD DB, or a
          MLMDConnectionManager which manages connections to multiple MLMD DBs.
        node: The pipeline node for which to generate.
        pipeline: The pipeline proto from which the node was taken (for context).
        skip_errors: A list of errors to skip on the given error types.
  
      Returns:
        A `ResolvedInfo` with input resolutions. If execution should be skipped,
        ResolvedInfo has empty input_and_params.
  
      Raises:
        InputResolutionError: If there are some errors when we try to resolve input.
      """
      # Register node contexts.
      contexts = context_lib.prepare_contexts(
          metadata_handle=mlmd_cm.get_handle(mlmd_handle_like),
          node_contexts=node.contexts,
      )
  
      result = ResolvedInfo(
          contexts=contexts,
          input_and_params=[],
      )
  
      # Resolve execution properties.
      exec_properties = resolve_exec_properties(node)
  
      # Resolve inputs.
      try:
          resolved_input_artifacts: Sequence[
              typing_utils.ArtifactMultiMap
          ] = inputs_utils.resolve_input_artifacts(
              metadata_handle=mlmd_handle_like, pipeline_node=node
          )
      except exceptions.InputResolutionError as e:
          for skip_error in skip_errors:
              if isinstance(e, skip_error):
                  logging.info(
                      "[%s] Input resolution skipped: %s",
                      node.node_info.id,
                      e,
                  )
                  return result
          raise
      if not resolved_input_artifacts:
          return result
  
      for input_artifacts in resolved_input_artifacts:
          try:
              dynamic_exec_properties = (
                  inputs_utils.resolve_dynamic_parameters(
                      node_parameters=node.parameters,
                      context=_create_placeholder_context(
                          pipeline, node, input_artifacts
                      ),
                  )
              )
          except exceptions.InputResolutionError as e:
              logging.exception(
                  "[%s] Parameter resolution error: %s",
                  node.node_info.id,
                  e,
              )
              raise
  
          result.input_and_params.append(
              InputAndParam(
                  input_artifacts=input_artifacts,
                  exec_properties={
                      **exec_properties,
                      **dynamic_exec_properties,
                  },
              )
          )
  
      return result
  
imports: import collections
  import itertools
  import json
  import sys
  import textwrap
  from typing import Callable, Dict, Iterable, List, MutableMapping, Optional, Sequence, Type
  import uuid
  from absl import logging
  import attr
  from tfx import types
  from tfx.dsl.compiler import constants
  from tfx.dsl.compiler import placeholder_utils
  from tfx.orchestration import data_types_utils
  from tfx.orchestration import metadata
  from tfx.orchestration import node_proto_view
  from tfx.orchestration.experimental.core import constants
  from tfx.orchestration.experimental.core import mlmd_state
  from tfx.orchestration.experimental.core import task
  from tfx.orchestration import mlmd_connection_manager
  from tfx.orchestration.portable import data_types
  from tfx.orchestration.portable import inputs_utils
  from tfx.orchestration.portable import outputs_utils
  from tfx.orchestration.portable.input_resolution import exceptions
  from tfx.orchestration.portable.mlmd import common_utils
  from tfx.orchestration.portable.mlmd import context_lib
  from tfx.orchestration.portable.mlmd import event_lib
  from tfx.orchestration.portable.mlmd import execution_lib
  from tfx.orchestration.portable.mlmd import filter_query_builder
  from tfx.proto.orchestration import pipeline_pb2
  from tfx.utils import proto_utils
  from tfx.utils import status
  from tfx.utils import typing_utils
  from tfx.orchestration.experimental.core import deployment_config_utils
  import ml_metadata
  from ml_metadata import errors
  from ml_metadata.proto import metadata_store_pb2
label_desc: Use image node_id 6 for calling a global function with example usage: generate_resolved_info(mlmd_handle_like, node, pipeline, skip_errors) and returns: result, result, result