





from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
   import numpy as np
   import tensorflow as tf

   from transformers import (
       TF_MODEL_FOR_CAUSAL_LM_MAPPING,
       TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
       TF_MODEL_FOR_MASKED_LM_MAPPING,
       TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
       TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
       TF_MODEL_FOR_PRETRAINING_MAPPING,
       TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
       TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
       TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
       TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
       TFSharedEmbeddings,
   )

   if _tf_gpu_memory_limit is not None:
      A__:  Dict       					=					tf.config.list_physical_devices('''GPU''')
      for gpu in gpus:
         # Restrict TensorFlow to only allocate x GB of memory on the GPUs
         try:
            tf.config.set_logical_device_configuration(
                gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
            )
            A__:  Optional[Any]       					=					tf.config.list_logical_devices('''GPU''')
            print('''Logical GPUs''', logical_gpus)
         except RuntimeError as e:
            # Virtual devices must be set before GPUs have been initialized
            print(e)




@require_tf
class    _a  :

      """simple docstring"""


      UpperCamelCase__       						=   None
      UpperCamelCase__       						=   ()
      UpperCamelCase__       						=   ()
      UpperCamelCase__       						=   True
      UpperCamelCase__       						=   True
      UpperCamelCase__       						=   True
      UpperCamelCase__       						=   False






      def 	UpperCAmelCase_   (						self:	str					,  __lowerCamelCase:	Optional[int]					,  __lowerCamelCase:	List[Any]					,  __lowerCamelCase:	int=False			):
          '''simple docstring'''


          UpperCamelCase__:					Any												=      copy.deepcopy(__lowerCamelCase			)

          if model_class in get_values(__lowerCamelCase			):
              UpperCamelCase__:					List[str]												=      {
                  k: tf.tile(tf.expand_dims(__lowerCamelCase					,  1			)					,  (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)			)
                  if isinstance(__lowerCamelCase					,  tf.Tensor			) and v.ndim > 0
                  else v
                  for k, v in inputs_dict.items()
              }

          if return_labels:
              if model_class in get_values(__lowerCamelCase			):
                  UpperCamelCase__:					Optional[int]												=      tf.ones(self.model_tester.batch_size					,  dtype=tf.intaa			)
              elif model_class in get_values(__lowerCamelCase			):
                  UpperCamelCase__:					Tuple												=      tf.zeros(self.model_tester.batch_size					,  dtype=tf.intaa			)
                  UpperCamelCase__:					Tuple												=      tf.zeros(self.model_tester.batch_size					,  dtype=tf.intaa			)
              elif model_class in [
                  *get_values(__lowerCamelCase			),
                  *get_values(__lowerCamelCase			),
              ]:
                  UpperCamelCase__:					str												=      tf.zeros(self.model_tester.batch_size					,  dtype=tf.intaa			)
              elif model_class in get_values(__lowerCamelCase			):
                  UpperCamelCase__:					Tuple												=      tf.zeros(self.model_tester.batch_size					,  dtype=tf.intaa			)
              elif model_class in [
                  *get_values(__lowerCamelCase			),
                  *get_values(__lowerCamelCase			),
                  *get_values(__lowerCamelCase			),
                  *get_values(__lowerCamelCase			),
                  *get_values(__lowerCamelCase			),
              ]:
                  UpperCamelCase__:					Dict												=      tf.zeros(
                      (self.model_tester.batch_size, self.model_tester.seq_length)					,  dtype=tf.intaa			)
          return inputs_dict






      @slow
      def 	UpperCAmelCase_   (						self:	Dict			):
          '''simple docstring'''


          UpperCamelCase__:					str												=      self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
              UpperCamelCase__:					Union[str, Any]												=      self._prepare_for_class(__lowerCamelCase					,  __lowerCamelCase			)
              UpperCamelCase__:					Tuple												=      model_class(__lowerCamelCase			)

              @tf.function
              def run_in_graph_mode():
                  return model(__lowerCamelCase			)

              UpperCamelCase__:					Tuple												=      run_in_graph_mode()
              self.assertIsNotNone(__lowerCamelCase			)






      @slow
      def 	UpperCAmelCase_   (						self:	Optional[Any]			):
          '''simple docstring'''


          UpperCamelCase__:					List[Any]												=      self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
              UpperCamelCase__:					str												=      self._prepare_for_class(__lowerCamelCase					,  __lowerCamelCase			)
              UpperCamelCase__:					Union[str, Any]												=      model_class(__lowerCamelCase			)

              @tf.function(experimental_compile=__lowerCamelCase			)
              def run_in_graph_mode():
                  return model(__lowerCamelCase			)

              UpperCamelCase__:					Any												=      run_in_graph_mode()
              self.assertIsNotNone(__lowerCamelCase			)






      @slow
      def 	UpperCAmelCase_   (						self:	Optional[Any]			):
          '''simple docstring'''


          UpperCamelCase__:					Any												=      self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
              UpperCamelCase__:					Optional[Any]												=      model_class(__lowerCamelCase			)
              if getattr(__lowerCamelCase					,  "hf_compute_loss"					,  __lowerCamelCase			):
                  # Test that model correctly compute the loss with kwargs
                  UpperCamelCase__:					List[Any]												=      self._prepare_for_class(inputs_dict.copy()					,  __lowerCamelCase					,  return_labels=__lowerCamelCase			)
                  # Is there a better way to remove these decoder inputs?
                  UpperCamelCase__:					int												=      {
                      key: val
                      for key, val in prepared_for_class.items()
                      if key not in ("head_mask", "decoder_head_mask", "cross_attn_head_mask", "decoder_input_ids")
                  }

                  UpperCamelCase__:					Union[str, Any]												=      {
                      "labels",
                      "label",
                      "label_ids",
                      "start_positions",
                      "start_position",
                      "end_positions",
                      "end_position",
                      "next_sentence_label",
                  }
                  UpperCamelCase__:					List[Any]												=      possible_label_cols.intersection(set(__lowerCamelCase			)			)
                  self.assertGreater(len(__lowerCamelCase			)					,  0					,  msg="No matching label names found!"			)
                  UpperCamelCase__:					str												=      {key: val for key, val in prepared_for_class.items() if key in label_names}
                  UpperCamelCase__:					Optional[int]												=      {key: val for key, val in prepared_for_class.items() if key not in label_names}
                  self.assertGreater(len(__lowerCamelCase			)					,  0			)

                  # Make sure it works with XLA!
                  model.compile(optimizer=tf.keras.optimizers.SGD(0.0			)					,  jit_compile=__lowerCamelCase			)
                  # Make sure the model fits without crashing regardless of where we pass the labels
                  UpperCamelCase__:					Optional[int]												=      model.fit(
                      __lowerCamelCase					,  validation_data=__lowerCamelCase					,  steps_per_epoch=1					,  validation_steps=1					,  shuffle=__lowerCamelCase					,  verbose=0					,  )
                  UpperCamelCase__:					Union[str, Any]												=      history.history["loss"][0]
                  self.assertTrue(not isnan(__lowerCamelCase			)			)
                  UpperCamelCase__:					List[Any]												=      history.history["val_loss"][0]
                  self.assertTrue(not isnan(__lowerCamelCase			)			)

                  # Now test it with separate labels, to make sure that path works in XLA too.
                  UpperCamelCase__:					Dict												=      model_class(__lowerCamelCase			)
                  model.compile(optimizer=tf.keras.optimizers.SGD(0.0			)					,  jit_compile=__lowerCamelCase			)
                  UpperCamelCase__:					int												=      model.fit(
                      __lowerCamelCase					,  __lowerCamelCase					,  validation_data=(inputs_minus_labels, labels)					,  steps_per_epoch=1					,  validation_steps=1					,  shuffle=__lowerCamelCase					,  verbose=0					,  )

                  UpperCamelCase__:					int												=      history.history["loss"][0]
                  self.assertTrue(not isnan(__lowerCamelCase			)			)
                  UpperCamelCase__:					Optional[Any]												=      history.history["val_loss"][0]
                  self.assertTrue(not isnan(__lowerCamelCase			)			)






      @slow
      def 	UpperCAmelCase_   (						self:	Union[str, Any]			):
          '''simple docstring'''


          UpperCamelCase__:					Optional[Any]												=      self.model_tester.prepare_config_and_inputs_for_common()
          UpperCamelCase__:					Any												=      True
          UpperCamelCase__:					Dict												=      True

          if hasattr(__lowerCamelCase					,  "use_cache"			):
              UpperCamelCase__:					List[str]												=      True

          UpperCamelCase__:					Optional[Any]												=      getattr(self.model_tester					,  "encoder_seq_length"					,  self.model_tester.seq_length			)
          UpperCamelCase__:					Optional[Any]												=      getattr(self.model_tester					,  "key_length"					,  __lowerCamelCase			)

          for model_class in self.all_model_classes[:2]:
              UpperCamelCase__:					Optional[int]												=      self._prepare_for_class(__lowerCamelCase					,  __lowerCamelCase			)
              UpperCamelCase__:					Union[str, Any]												=      model_class(__lowerCamelCase			)
              model.build()
              UpperCamelCase__:					Union[str, Any]												=      len(model(__lowerCamelCase			)			)

              for key in list(class_inputs_dict.keys()			):
                  # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
                  if key not in model.input_signature:
                      del class_inputs_dict[key]
                  # Check it's a tensor, in case the inputs dict has some bools in it too
                  elif isinstance(class_inputs_dict[key]					,  tf.Tensor			) and class_inputs_dict[key].dtype.is_integer:
                      UpperCamelCase__:					List[Any]												=      tf.cast(class_inputs_dict[key]					,  tf.intaa			)

              if set(class_inputs_dict.keys()			) != set(model.input_signature.keys()			):
                  continue  # Some models have inputs that the preparation functions don't create, we skip those

              with tempfile.TemporaryDirectory() as tmpdirname:
                  model.save_pretrained(__lowerCamelCase					,  saved_model=__lowerCamelCase			)
                  UpperCamelCase__:					Dict												=      os.path.join(__lowerCamelCase					,  "saved_model"					,  "1"			)
                  UpperCamelCase__:					str												=      tf.keras.models.load_model(__lowerCamelCase			)
                  UpperCamelCase__:					Union[str, Any]												=      model(__lowerCamelCase			)

                  if self.is_encoder_decoder:
                      UpperCamelCase__:					Optional[int]												=      outputs["encoder_hidden_states"]
                      UpperCamelCase__:					int												=      outputs["encoder_attentions"]
                  else:
                      UpperCamelCase__:					Tuple												=      outputs["hidden_states"]
                      UpperCamelCase__:					Optional[Any]												=      outputs["attentions"]

                  self.assertEqual(len(__lowerCamelCase			)					,  __lowerCamelCase			)

                  UpperCamelCase__:					List[Any]												=      getattr(
                      self.model_tester					,  "expected_num_hidden_layers"					,  self.model_tester.num_hidden_layers + 1			)

                  self.assertEqual(len(__lowerCamelCase			)					,  __lowerCamelCase			)
                  self.assertListEqual(
                      list(output_hidden_states[0].shape[-2:]			)					,  [self.model_tester.seq_length, self.model_tester.hidden_size]					,  )

                  self.assertEqual(len(__lowerCamelCase			)					,  self.model_tester.num_hidden_layers			)
                  self.assertListEqual(
                      list(output_attentions[0].shape[-3:]			)					,  [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,  )






      @slow
      def 	UpperCAmelCase_   (						self:	Tuple			):
          '''simple docstring'''


          tf.keras.mixed_precision.set_global_policy("mixed_float16"			)

          # try/finally block to ensure subsequent tests run in float32
          try:
              UpperCamelCase__:					str												=      self.model_tester.prepare_config_and_inputs_for_common()
              for model_class in self.all_model_classes[:2]:
                  UpperCamelCase__:					Optional[int]												=      self._prepare_for_class(__lowerCamelCase					,  __lowerCamelCase			)
                  UpperCamelCase__:					List[str]												=      model_class(__lowerCamelCase			)
                  UpperCamelCase__:					Any												=      model(__lowerCamelCase			)

                  self.assertIsNotNone(__lowerCamelCase			)
          finally:
              tf.keras.mixed_precision.set_global_policy("float32"			)






      @slow
      def 	UpperCAmelCase_   (						self:	Optional[Any]			):
          '''simple docstring'''


          UpperCamelCase__:					Tuple												=      self.model_tester.prepare_config_and_inputs_for_common()
          # head_mask and decoder_head_mask has different shapes than other input args
          if "head_mask" in inputs_dict:
              del inputs_dict["head_mask"]
          if "decoder_head_mask" in inputs_dict:
              del inputs_dict["decoder_head_mask"]
          if "cross_attn_head_mask" in inputs_dict:
              del inputs_dict["cross_attn_head_mask"]
          UpperCamelCase__:					str												=      {
              module_member
              for model_class in self.all_model_classes
              for module in (import_module(model_class.__module__			),)
              for module_member_name in dir(__lowerCamelCase			)
              if module_member_name.endswith("MainLayer"			)
              for module_member in (getattr(__lowerCamelCase					,  __lowerCamelCase			),)
              if isinstance(__lowerCamelCase					,  __lowerCamelCase			)
              and tf.keras.layers.Layer in module_member.__bases__
              and getattr(__lowerCamelCase					,  "_keras_serializable"					,  __lowerCamelCase			)
          }

          for main_layer_class in tf_main_layer_classes:
              # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
              if "T5" in main_layer_class.__name__:
                  # Take the same values than in TFT5ModelTester for this shared layer
                  UpperCamelCase__:					Union[str, Any]												=      TFSharedEmbeddings(self.model_tester.vocab_size					,  self.model_tester.hidden_size					,  name="shared"			)
                  UpperCamelCase__:					Any												=      False
                  UpperCamelCase__:					Optional[Any]												=      main_layer_class(__lowerCamelCase					,  embed_tokens=__lowerCamelCase			)
              else:
                  UpperCamelCase__:					str												=      main_layer_class(__lowerCamelCase			)

              UpperCamelCase__:					Any												=      {
                  name: tf.keras.Input(tensor.shape[1:]					,  dtype=tensor.dtype			) for name, tensor in inputs_dict.items()
              }

              if hasattr(self.model_tester					,  "num_labels"			):
                  UpperCamelCase__:					Any												=      self.model_tester.num_labels
              else:
                  UpperCamelCase__:					List[Any]												=      2

              UpperCamelCase__:					Dict												=      tf.data.Dataset.from_tensor_slices(
                  (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)			))			).batch(1			)

              UpperCamelCase__:					str												=      main_layer(__lowerCamelCase			)[0]
              UpperCamelCase__:					str												=      tf.keras.layers.Dense(__lowerCamelCase					,  activation="softmax"					,  name="outputs"			)(__lowerCamelCase			)
              UpperCamelCase__:					List[Any]												=      tf.keras.models.Model(inputs=__lowerCamelCase					,  outputs=[outputs]			)

              model.compile(loss="binary_crossentropy"					,  optimizer="adam"					,  metrics=["binary_accuracy"]			)
              model.fit(__lowerCamelCase					,  epochs=1			)

              with tempfile.TemporaryDirectory() as tmpdirname:
                  UpperCamelCase__:					int												=      os.path.join(__lowerCamelCase					,  "keras_model.h5"			)
                  model.save(__lowerCamelCase			)
                  if "T5" in main_layer_class.__name__:
                      UpperCamelCase__:					Optional[int]												=      tf.keras.models.load_model(
                          __lowerCamelCase					,  custom_objects={
                              main_layer_class.__name__: main_layer_class,
                              "TFSharedEmbeddings": TFSharedEmbeddings,
                          }					,  )
                  else:
                      UpperCamelCase__:					Optional[int]												=      tf.keras.models.load_model(
                          __lowerCamelCase					,  custom_objects={main_layer_class.__name__: main_layer_class}			)
                  assert isinstance(__lowerCamelCase					,  tf.keras.Model			)
                  model(__lowerCamelCase			)






      @slow
      def 	UpperCAmelCase_   (						self:	Any			):
          '''simple docstring'''


          UpperCamelCase__:					Any												=      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes[:2]:
              UpperCamelCase__:					Optional[int]												=      model_class(__lowerCamelCase			)

              UpperCamelCase__:					Tuple												=      copy.deepcopy(__lowerCamelCase			)

              if not self.is_encoder_decoder:
                  UpperCamelCase__:					Any												=      inputs["input_ids"]
                  del inputs["input_ids"]
              else:
                  UpperCamelCase__:					Optional[Any]												=      inputs["input_ids"]
                  UpperCamelCase__:					List[str]												=      inputs.get("decoder_input_ids"					,  __lowerCamelCase			)
                  del inputs["input_ids"]
                  inputs.pop("decoder_input_ids"					,  __lowerCamelCase			)

              if not self.is_encoder_decoder:
                  UpperCamelCase__:					int												=      model.get_input_embeddings()(__lowerCamelCase			)
              else:
                  UpperCamelCase__:					Dict												=      model.get_input_embeddings()(__lowerCamelCase			)
                  UpperCamelCase__:					Any												=      model.get_input_embeddings()(__lowerCamelCase			)

              UpperCamelCase__:					int												=      self._prepare_for_class(__lowerCamelCase					,  __lowerCamelCase			)

              @tf.function
              def run_in_graph_mode():
                  return model(__lowerCamelCase			)

              UpperCamelCase__:					List[str]												=      run_in_graph_mode()
              self.assertIsNotNone(__lowerCamelCase			)






      def 	UpperCAmelCase_   (						self:	Union[str, Any]					,  __lowerCamelCase:	List[str]					,  __lowerCamelCase:	Union[str, Any]			):
          '''simple docstring'''


          UpperCamelCase__:					Tuple												=      []
          if model.config.bos_token_id is not None:
              special_tokens.append(model.config.bos_token_id			)
          if model.config.pad_token_id is not None:
              special_tokens.append(model.config.pad_token_id			)
          if model.config.eos_token_id is not None:
              special_tokens.append(model.config.eos_token_id			)

          # create random bad tokens that are not special tokens
          UpperCamelCase__:					Tuple												=      []
          while len(__lowerCamelCase			) < num_bad_tokens:
              UpperCamelCase__:					Dict												=      tf.squeeze(ids_tensor((1, 1)					,  self.model_tester.vocab_size			)					,  0			).numpy()[0]
              if token not in special_tokens:
                  bad_tokens.append(__lowerCamelCase			)
          return bad_tokens






      def 	UpperCAmelCase_   (						self:	str					,  __lowerCamelCase:	Optional[Any]			):
          '''simple docstring'''


          for token_id in output_ids[0].numpy().tolist():
              self.assertGreaterEqual(__lowerCamelCase					,  0			)
              self.assertLess(__lowerCamelCase					,  self.model_tester.vocab_size			)






      def 	UpperCAmelCase_   (						self:	str					,  __lowerCamelCase:	Optional[int]					,  __lowerCamelCase:	Any			):
          '''simple docstring'''


          for bad_word_ids in bad_words_ids:
              # for all slices in batch
              for generated_ids_slice in generated_ids:
                  # for all word idx
                  for i in range(len(__lowerCamelCase			)					,  len(__lowerCamelCase			)			):
                      # if tokens match
                      if generated_ids_slice[i - len(__lowerCamelCase			) : i] == bad_word_ids:
                          return True
          return False








import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor



def 							lowerCAmelCase_				(    ):
    UpperCamelCase__:					Optional[Any]												=      set()
    # Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
    for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
        UpperCamelCase__:					Tuple												=      getattr(transformers.models.auto  ,A_  ,A_)
        if module is None:
            continue
        # all mappings in a single auto modeling file
        UpperCamelCase__:					Union[str, Any]												=      [
            x
            for x in dir(A_)
            if x.endswith("_MAPPING_NAMES")
            and (x.startswith("MODEL_") or x.startswith("TF_MODEL_") or x.startswith("FLAX_MODEL_"))
        ]
        for name in mapping_names:
            UpperCamelCase__:					Union[str, Any]												=      getattr(A_  ,A_)
            if mapping is not None:
                for v in mapping.values():
                    if isinstance(A_  ,(list, tuple)):
                        model_names.update(A_)
                    elif isinstance(A_  ,A_):
                        model_names.add(A_)

    return sorted(A_)



def 							lowerCAmelCase_				(    ):
    # All model names defined in auto mappings
    UpperCamelCase__:					Any												=      set(get_all_model_names())

    with open("tests/utils/tiny_model_summary.json") as fp:
        UpperCamelCase__:					Union[str, Any]												=      json.load(A_)
    UpperCamelCase__:					Union[str, Any]												=      set()
    for model_base_name in tiny_model_info:
        tiny_models_names.update(tiny_model_info[model_base_name]["model_classes"])

    # Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
    UpperCamelCase__:					Any												=      model_names.difference(A_)
    for model_name in copy.copy(A_):
        if not model_name.startswith("TF") and F"TF{model_name}" in not_on_hub:
            tiny_models_names.remove(A_)
        elif model_name.startswith("TF") and model_name[2:] in not_on_hub:
            tiny_models_names.remove(A_)

    return sorted(A_)



def 							lowerCAmelCase_				(    A_):
    UpperCamelCase__:					int												=      COMPOSITE_MODELS.values()

    # All tiny model base names on Hub
    UpperCamelCase__:					Any												=      get_all_model_names()
    UpperCamelCase__:					Tuple												=      hf_api.list_models(
        filter=ModelFilter(
            author="hf-internal-testing"  ,))
    UpperCamelCase__:					Optional[Any]												=      set()
    for x in models:
        UpperCamelCase__:					List[str]												=      x.modelId
        UpperCamelCase__							,				UpperCamelCase__:					Any												=      model.split("/")
        if not model.startswith("tiny-random-"):
            continue
        UpperCamelCase__:					Tuple												=      model.replace("tiny-random-"  ,"")
        if not model[0].isupper():
            continue
        if model not in model_names and model not in special_models:
            continue
        _models.add(A_)

    UpperCamelCase__:					List[Any]												=      sorted(_models)
    # All tiny model names on Hub
    UpperCamelCase__:					List[str]												=      {}
    for model in models:
        UpperCamelCase__:					str												=      F"hf-internal-testing/tiny-random-{model}"
        UpperCamelCase__:					Union[str, Any]												=      model.split("-")[0]
        try:
            UpperCamelCase__:					Any												=      hf_api.repo_info(A_)
            UpperCamelCase__:					int												=      {
                "tokenizer_classes": set(),
                "processor_classes": set(),
                "model_classes": set(),
                "sha": repo_info.sha,
            }
        except Exception:
            continue
        try:
            time.sleep(1)
            UpperCamelCase__:					Any												=      AutoTokenizer.from_pretrained(A_)
            content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__)
        except Exception:
            pass
        try:
            time.sleep(1)
            UpperCamelCase__:					str												=      AutoTokenizer.from_pretrained(A_  ,use_fast=A_)
            content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__)
        except Exception:
            pass
        try:
            time.sleep(1)
            UpperCamelCase__:					List[str]												=      AutoImageProcessor.from_pretrained(A_)
            content["processor_classes"].add(img_p.__class__.__name__)
        except Exception:
            pass
        try:
            time.sleep(1)
            UpperCamelCase__:					Union[str, Any]												=      AutoFeatureExtractor.from_pretrained(A_)
            if not isinstance(A_  ,A_):
                content["processor_classes"].add(feat_p.__class__.__name__)
        except Exception:
            pass
        try:
            time.sleep(1)
            UpperCamelCase__:					List[str]												=      getattr(A_  ,A_)
            UpperCamelCase__:					Union[str, Any]												=      model_class.from_pretrained(A_)
            content["model_classes"].add(m.__class__.__name__)
        except Exception:
            pass
        try:
            time.sleep(1)
            UpperCamelCase__:					str												=      getattr(A_  ,F"TF{model}")
            UpperCamelCase__:					Optional[Any]												=      model_class.from_pretrained(A_)
            content["model_classes"].add(m.__class__.__name__)
        except Exception:
            pass

        UpperCamelCase__:					Optional[int]												=      sorted(content["tokenizer_classes"])
        UpperCamelCase__:					List[str]												=      sorted(content["processor_classes"])
        UpperCamelCase__:					Optional[int]												=      sorted(content["model_classes"])

        UpperCamelCase__:					int												=      content
        with open(os.path.join(A_  ,"hub_tiny_model_summary.json")  ,"w") as fp:
            json.dump(A_  ,A_  ,ensure_ascii=A_  ,indent=4)


if __name__ == "__main__":
   A__:  Optional[Any]       					=					argparse.ArgumentParser()
   parser.add_argument('''--num_workers''', default=1, type=int, help='''The number of workers to run.''')
   A__:  Dict       					=					parser.parse_args()

   # This has to be `spawn` to avoid hanging forever!
   multiprocessing.set_start_method('''spawn''')

   A__:  List[Any]       					=					'''tiny_models'''
   A__:  Dict       					=					True
   A__:  Dict       					=					None
   A__:  Optional[Any]       					=					get_tiny_model_names_from_repo()
   A__:  int       					=					True
   A__:  int       					=					True
   A__:  int       					=					'''hf-internal-testing'''

   create_tiny_models(
       output_path,
       all,
       model_types,
       models_to_skip,
       no_check,
       upload,
       organization,
       token=os.environ.get('''TOKEN''', None),
       num_workers=args.num_workers,
   )

