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_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")]
  
imports: import unittest
  from tempfile import TemporaryDirectory
  from typing import TYPE_CHECKING, Dict, Optional
  import pytest
  from parameterized import parameterized
  from transformers import AutoConfig, is_tf_available
  from transformers.testing_utils import require_tf
  from optimum.utils import DEFAULT_DUMMY_SHAPES
  from ...utils.test_task_processors import TASK_TO_NON_DEFAULT_DATASET
  from ..exporters_utils import PYTORCH_EXPORT_MODELS_TINY
  import subprocess
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