code: def _get_models_to_test(export_models_dict: Dict):
      models_to_test = []
      if is_tf_available():
          for (
              model_type,
              model_names_tasks,
          ) in export_models_dict.items():
              model_type = model_type.replace("_", "-")
              try:
                  task_config_mapping = (
                      TasksManager.get_supported_tasks_for_model_type(
                          model_type, "tflite"
                      )
                  )
              except KeyError:
                  # In this case the model is either not supported, or the contributor forgot to register the
                  # TFLiteConfig in the TasksManager.
                  # We check that supported model was left unregistered for a backend in the TasksManager unit tests, so
                  # we can simply skip in this case here.
                  continue
  
              if isinstance(
                  model_names_tasks, str
              ):  # test export of all tasks on the same model
                  tasks = list(task_config_mapping.keys())
                  model_tasks = {model_names_tasks: tasks}
              else:
                  unique_tasks = set()
                  for tasks in model_names_tasks.values():
                      for task in tasks:
                          unique_tasks.add(task)
                  n_tested_tasks = len(unique_tasks)
                  if n_tested_tasks != len(task_config_mapping):
                      raise ValueError(
                          f"Not all tasks are tested for {model_type}."
                      )
                  model_tasks = model_names_tasks  # possibly, test different tasks on different models
  
              for model_name, tasks in model_tasks.items():
                  for task in tasks:
                      default_shapes = dict(DEFAULT_DUMMY_SHAPES)
                      if task == "question-answering":
                          default_shapes["sequence_length"] = 384
                      tflite_config_constructor = (
                          TasksManager.get_exporter_config_constructor(
                              model_type=model_type,
                              exporter="tflite",
                              task=task,
                              model_name=model_name,
                              exporter_config_kwargs={**default_shapes},
                          )
                      )
  
                      models_to_test.append(
                          (
                              f"{model_type}_{task}",
                              model_type,
                              model_name,
                              task,
                              tflite_config_constructor,
                          )
                      )
  
          return sorted(models_to_test)
      else:
          # Returning some dummy test that should not be ever called because of the @require_torch / @require_tf
          # decorators.
          # The reason for not returning an empty list is because parameterized.expand complains when it's empty.
          return [("dummy", "dummy", "dummy", "dummy", lambda x: x)]
  
imports: from contextlib import nullcontext
  from pathlib import Path
  from tempfile import NamedTemporaryFile
  from typing import Dict, Optional, Union
  from unittest import TestCase
  import pytest
  from parameterized import parameterized
  from transformers import AutoConfig, is_tf_available
  from transformers.testing_utils import require_tf, require_vision, slow
  from optimum.exporters.tflite import TFLiteQuantizationConfig, export, validate_model_outputs
  from optimum.exporters.tflite.base import QuantizationApproachNotSupported
  from optimum.utils import DEFAULT_DUMMY_SHAPES
  from optimum.utils.preprocessing import Preprocessor
  from optimum.utils.save_utils import maybe_load_preprocessors
  from ...utils.test_task_processors import TASK_TO_NON_DEFAULT_DATASET
  from ..exporters_utils import PYTORCH_EXPORT_MODELS_TINY
label_desc: Use image node_id 1 for calling a global function with example usage: _get_models_to_test(export_models_dict) and returns: sorted, list