code: def resolve(
      handle_like: mlmd_cm.HandleLike,
      node_inputs: pipeline_pb2.NodeInputs,
  ) -> List[typing_utils.ArtifactMultiMap]:
      """Resolve a NodeInputs."""
      resolved: Dict[str, List[_Entry]] = collections.defaultdict(list)
  
      for input_key in _topologically_sorted_input_keys(
          node_inputs.inputs, node_inputs.input_graphs
      ):
          # This input_key may have been already resolved while resolving for another
          # input key.
          if input_key in resolved:
              continue
  
          input_spec = node_inputs.inputs[input_key]
  
          if input_spec.channels:
              artifacts = channel_resolver.resolve_union_channels(
                  handle_like, input_spec.channels
              )
              resolved[input_key] = [
                  (
                      partition_utils.NO_PARTITION,
                      _filter_live(artifacts),
                  )
              ]
          elif input_spec.input_graph_ref.graph_id:
              _resolve_input_graph_ref(
                  mlmd_cm.get_handle(handle_like),
                  node_inputs,
                  input_key,
                  resolved,
              )
          elif input_spec.mixed_inputs.input_keys:
              _resolve_mixed_inputs(node_inputs, input_key, resolved)
          elif input_spec.HasField("static_inputs"):
              artifacts = _resolve_static_inputs(
                  mlmd_cm.get_handle(handle_like),
                  input_spec.static_inputs,
              )
              resolved[input_key] = [
                  (partition_utils.NO_PARTITION, artifacts)
              ]
          else:
              raise exceptions.FailedPreconditionError(
                  "Exactly one of InputSpec.channels, InputSpec.input_graph_ref, or "
                  "InputSpec.mixed_inputs should be set."
              )
  
          if input_spec.min_count:
              for _, artifacts in resolved[input_key]:
                  if len(artifacts) < input_spec.min_count:
                      raise exceptions.InsufficientInputError(
                          "InputSpec min_count has not met: "
                          f"inputs[{input_key}] has min_count = {input_spec.min_count} "
                          f"but only got {len(artifacts)} artifacts. "
                          f"(Artifact IDs: {[a.id for a in artifacts]})"
                      )
  
      visible_keys = [
          k
          for k, input_spec in node_inputs.inputs.items()
          if not input_spec.hidden
      ]
      result = [
          artifact_map
          for _, artifact_map in _join_artifacts(resolved, visible_keys)
      ]
  
      if node_inputs.conditionals:
          result = _filter_conditionals(
              result, node_inputs.conditionals
          )
  
      return result
  
imports: import collections
  from typing import Dict, Iterable, List, Mapping, Sequence, Tuple, TypeVar
  from tfx import types
  from tfx.dsl.compiler import placeholder_utils
  from tfx.orchestration import metadata
  from tfx.orchestration import mlmd_connection_manager
  from tfx.orchestration.portable import data_types
  from tfx.orchestration.portable.input_resolution import exceptions
  from tfx.orchestration.portable.input_resolution import input_graph_resolver
  from tfx.orchestration.portable.input_resolution import partition_utils
  from tfx.orchestration.portable.input_resolution import channel_resolver
  from tfx.proto.orchestration import pipeline_pb2
  from tfx.types import artifact_utils
  from tfx.utils import topsort
  from tfx.utils import typing_utils
  from tfx.utils import governance_utils
label_desc: Use image node_id 11 for calling a global function with example usage: resolve(handle_like, node_inputs) and returns: result