code: def strict_run_resolver_op(
      op_type: Type[resolver_op.ResolverOp],
      *,
      args: Tuple[Any, ...],
      kwargs: Mapping[str, Any],
      store: Optional[mlmd.MetadataStore] = None,
  ):
      """Runs ResolverOp with strict type checking."""
      if len(args) != len(op_type.arg_data_types):
          raise TypeError(
              f"len({op_type}.arg_data_types) = {len(op_type.arg_data_types)} but"
              f" got len(args) = {len(args)}"
          )
      if op_type.arg_data_types:
          for i, arg, expected_data_type in zip(
              range(len(args)), args, op_type.arg_data_types
          ):
              if (
                  expected_data_type
                  == resolver_op.DataType.ARTIFACT_LIST
              ):
                  if not typing_utils.is_artifact_list(arg):
                      raise TypeError(
                          f"Expected ARTIFACT_LIST but arg[{i}] = {arg}"
                      )
              elif (
                  expected_data_type
                  == resolver_op.DataType.ARTIFACT_MULTIMAP
              ):
                  if not typing_utils.is_artifact_multimap(arg):
                      raise TypeError(
                          f"Expected ARTIFACT_MULTIMAP but arg[{i}] = {arg}"
                      )
              elif (
                  expected_data_type
                  == resolver_op.DataType.ARTIFACT_MULTIMAP_LIST
              ):
                  if not typing_utils.is_list_of_artifact_multimap(arg):
                      raise TypeError(
                          f"Expected ARTIFACT_MULTIMAP_LIST but arg[{i}] = {arg}"
                      )
      op = op_type.create(**kwargs)
      context = resolver_op.Context(
          store=store
          if store is not None
          else mock.MagicMock(spec=mlmd.MetadataStore)
      )
      op.set_context(context)
      result = op.apply(*args)
      if op_type.return_data_type == resolver_op.DataType.ARTIFACT_LIST:
          if not typing_utils.is_homogeneous_artifact_list(result):
              raise TypeError(
                  f"Expected ARTIFACT_LIST result but got {result}"
              )
      elif (
          op_type.return_data_type
          == resolver_op.DataType.ARTIFACT_MULTIMAP
      ):
          if not typing_utils.is_artifact_multimap(result):
              raise TypeError(
                  f"Expected ARTIFACT_MULTIMAP result but got {result}"
              )
      elif (
          op_type.return_data_type
          == resolver_op.DataType.ARTIFACT_MULTIMAP_LIST
      ):
          if not typing_utils.is_list_of_artifact_multimap(result):
              raise TypeError(
                  f"Expected ARTIFACT_MULTIMAP_LIST result but got {result}"
              )
      return result
  
imports: from typing import Type, Any, Dict, List, Optional, Sequence, Tuple, Union, Mapping
  from unittest import mock
  from absl.testing import parameterized
  from tfx import types
  from tfx.dsl.compiler import compiler_context
  from tfx.dsl.compiler import node_inputs_compiler
  from tfx.dsl.components.base import base_component
  from tfx.dsl.components.base import base_driver
  from tfx.dsl.components.base import base_executor
  from tfx.dsl.components.base import executor_spec
  from tfx.dsl.input_resolution import resolver_op
  from tfx.dsl.input_resolution.ops import ops_utils
  from tfx.orchestration import pipeline
  from tfx.proto.orchestration import pipeline_pb2
  from tfx.types import artifact
  from tfx.types import artifact_utils
  from tfx.types import channel
  from tfx.types import component_spec
  from tfx.utils import test_case_utils
  from tfx.utils import typing_utils
  import ml_metadata
  from ml_metadata.proto import metadata_store_pb2
label_desc: Use image node_id 3 for calling a global function with example usage: strict_run_resolver_op(op_type) and returns: result