

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:
            _SCREAMING_SNAKE_CASE          = 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)]
                        )
                        _SCREAMING_SNAKE_CASE          = 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     lowerCamelCase_   :
 _lowerCAmelCase       		=  None
 _lowerCAmelCase       		=  ()
 _lowerCAmelCase       		=  ()
 _lowerCAmelCase       		=  True
 _lowerCAmelCase       		=  True
 _lowerCAmelCase       		=  True
 _lowerCAmelCase       		=  False




 def 						a					( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase     ,     _UpperCAmelCase=False       ):
   __UpperCAmelCase  :     Optional[int]		=    copy.deepcopy(_UpperCAmelCase       )

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

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




 @slow
 def 						a					( self       ):
   __UpperCAmelCase  :     Optional[int]		=    self.model_tester.prepare_config_and_inputs_for_common()
   for model_class in self.all_model_classes[:2]:
     __UpperCAmelCase  :     Tuple		=    self._prepare_for_class(_UpperCAmelCase     ,     _UpperCAmelCase       )
     __UpperCAmelCase  :     Union[str, Any]		=    model_class(_UpperCAmelCase       )

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

     __UpperCAmelCase  :     str		=    run_in_graph_mode()
     self.assertIsNotNone(_UpperCAmelCase       )




 @slow
 def 						a					( self       ):
   __UpperCAmelCase  :     List[str]		=    self.model_tester.prepare_config_and_inputs_for_common()
   for model_class in self.all_model_classes[:2]:
     __UpperCAmelCase  :     List[str]		=    self._prepare_for_class(_UpperCAmelCase     ,     _UpperCAmelCase       )
     __UpperCAmelCase  :     Optional[int]		=    model_class(_UpperCAmelCase       )

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

     __UpperCAmelCase  :     List[str]		=    run_in_graph_mode()
     self.assertIsNotNone(_UpperCAmelCase       )




 @slow
 def 						a					( self       ):
   # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
   __UpperCAmelCase  :     Union[str, Any]		=    self.model_tester.prepare_config_and_inputs_for_common()
   for model_class in self.all_model_classes[:2]:
     __UpperCAmelCase  :     List[str]		=    model_class(_UpperCAmelCase       )
     if getattr(_UpperCAmelCase     ,     'hf_compute_loss'     ,     _UpperCAmelCase       ):
       # Test that model correctly compute the loss with kwargs
       __UpperCAmelCase  :     Dict		=    self._prepare_for_class(inputs_dict.copy()     ,     _UpperCAmelCase     ,     return_labels=_UpperCAmelCase       )
       # Is there a better way to remove these decoder inputs?
       __UpperCAmelCase  :     Any		=    {
           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  :     Tuple		=    {
           'labels',
           'label',
           'label_ids',
           'start_positions',
           'start_position',
           'end_positions',
           'end_position',
           'next_sentence_label',
       }
       __UpperCAmelCase  :     str		=    possible_label_cols.intersection(set(_UpperCAmelCase       )       )
       self.assertGreater(len(_UpperCAmelCase       )     ,     0     ,     msg='No matching label names found!'       )
       __UpperCAmelCase  :     List[str]		=    {key: val for key, val in prepared_for_class.items() if key in label_names}
       __UpperCAmelCase  :     Tuple		=    {key: val for key, val in prepared_for_class.items() if key not in label_names}
       self.assertGreater(len(_UpperCAmelCase       )     ,     0       )

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

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

       __UpperCAmelCase  :     Optional[int]		=    history.history['loss'][0]
       self.assertTrue(not isnan(_UpperCAmelCase       )       )
       __UpperCAmelCase  :     Union[str, Any]		=    history.history['val_loss'][0]
       self.assertTrue(not isnan(_UpperCAmelCase       )       )




 @slow
 def 						a					( self       ):
   __UpperCAmelCase  :     List[str]		=    self.model_tester.prepare_config_and_inputs_for_common()
   __UpperCAmelCase  :     str		=    True
   __UpperCAmelCase  :     Union[str, Any]		=    True

   if hasattr(_UpperCAmelCase     ,     'use_cache'       ):
     __UpperCAmelCase  :     str		=    True

   __UpperCAmelCase  :     str		=    getattr(self.model_tester     ,     'encoder_seq_length'     ,     self.model_tester.seq_length       )
   __UpperCAmelCase  :     Optional[int]		=    getattr(self.model_tester     ,     'key_length'     ,     _UpperCAmelCase       )

   for model_class in self.all_model_classes[:2]:
     __UpperCAmelCase  :     Tuple		=    self._prepare_for_class(_UpperCAmelCase     ,     _UpperCAmelCase       )
     __UpperCAmelCase  :     Dict		=    model_class(_UpperCAmelCase       )
     model.build()
     __UpperCAmelCase  :     Any		=    len(model(_UpperCAmelCase       )       )

     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  :     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(_UpperCAmelCase     ,     saved_model=_UpperCAmelCase       )
       __UpperCAmelCase  :     List[str]		=    os.path.join(_UpperCAmelCase     ,     'saved_model'     ,     '1'       )
       __UpperCAmelCase  :     List[Any]		=    tf.keras.models.load_model(_UpperCAmelCase       )
       __UpperCAmelCase  :     Union[str, Any]		=    model(_UpperCAmelCase       )

       if self.is_encoder_decoder:
         __UpperCAmelCase  :     Dict		=    outputs['encoder_hidden_states']
         __UpperCAmelCase  :     Tuple		=    outputs['encoder_attentions']
       else:
         __UpperCAmelCase  :     Optional[int]		=    outputs['hidden_states']
         __UpperCAmelCase  :     Dict		=    outputs['attentions']

       self.assertEqual(len(_UpperCAmelCase       )     ,     _UpperCAmelCase       )

       __UpperCAmelCase  :     Any		=    getattr(
           self.model_tester     ,     'expected_num_hidden_layers'     ,     self.model_tester.num_hidden_layers + 1       )

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

       self.assertEqual(len(_UpperCAmelCase       )     ,     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 						a					( self       ):
   tf.keras.mixed_precision.set_global_policy('mixed_float16'       )

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

       self.assertIsNotNone(_UpperCAmelCase       )
   finally:
     tf.keras.mixed_precision.set_global_policy('float32'       )




 @slow
 def 						a					( self       ):
   __UpperCAmelCase  :     Optional[int]		=    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  :     Union[str, Any]		=    {
       module_member
       for model_class in self.all_model_classes
       for module in (import_module(model_class.__module__       ),)
       for module_member_name in dir(_UpperCAmelCase       )
       if module_member_name.endswith('MainLayer'       )
       for module_member in (getattr(_UpperCAmelCase     ,     _UpperCAmelCase       ),)
       if isinstance(_UpperCAmelCase     ,     _UpperCAmelCase       )
       and tf.keras.layers.Layer in module_member.__bases__
       and getattr(_UpperCAmelCase     ,     '_keras_serializable'     ,     _UpperCAmelCase       )
   }

   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  :     Optional[int]		=    TFSharedEmbeddings(self.model_tester.vocab_size     ,     self.model_tester.hidden_size     ,     name='shared'       )
       __UpperCAmelCase  :     int		=    False
       __UpperCAmelCase  :     Optional[Any]		=    main_layer_class(_UpperCAmelCase     ,     embed_tokens=_UpperCAmelCase       )
     else:
       __UpperCAmelCase  :     List[str]		=    main_layer_class(_UpperCAmelCase       )

     __UpperCAmelCase  :     Optional[int]		=    {
         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  :     Union[str, Any]		=    self.model_tester.num_labels
     else:
       __UpperCAmelCase  :     List[str]		=    2

     __UpperCAmelCase  :     List[Any]		=    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(_UpperCAmelCase       )[0]
     __UpperCAmelCase  :     Optional[int]		=    tf.keras.layers.Dense(_UpperCAmelCase     ,     activation='softmax'     ,     name='outputs'       )(_UpperCAmelCase       )
     __UpperCAmelCase  :     Tuple		=    tf.keras.models.Model(inputs=_UpperCAmelCase     ,     outputs=[outputs]       )

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

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




 @slow
 def 						a					( self       ):
   __UpperCAmelCase  :     Dict		=    self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes[:2]:
     __UpperCAmelCase  :     Any		=    model_class(_UpperCAmelCase       )

     __UpperCAmelCase  :     List[str]		=    copy.deepcopy(_UpperCAmelCase       )

     if not self.is_encoder_decoder:
       __UpperCAmelCase  :     int		=    inputs['input_ids']
       del inputs["input_ids"]
     else:
       __UpperCAmelCase  :     int		=    inputs['input_ids']
       __UpperCAmelCase  :     List[Any]		=    inputs.get('decoder_input_ids'     ,     _UpperCAmelCase       )
       del inputs["input_ids"]
       inputs.pop('decoder_input_ids'     ,     _UpperCAmelCase       )

     if not self.is_encoder_decoder:
       __UpperCAmelCase  :     Any		=    model.get_input_embeddings()(_UpperCAmelCase       )
     else:
       __UpperCAmelCase  :     Tuple		=    model.get_input_embeddings()(_UpperCAmelCase       )
       __UpperCAmelCase  :     Any		=    model.get_input_embeddings()(_UpperCAmelCase       )

     __UpperCAmelCase  :     Optional[int]		=    self._prepare_for_class(_UpperCAmelCase     ,     _UpperCAmelCase       )

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

     __UpperCAmelCase  :     int		=    run_in_graph_mode()
     self.assertIsNotNone(_UpperCAmelCase       )




 def 						a					( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase       ):
   # special tokens cannot be bad tokens
   __UpperCAmelCase  :     Union[str, Any]		=    []
   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  :     Optional[Any]		=    []
   while len(_UpperCAmelCase       ) < num_bad_tokens:
     __UpperCAmelCase  :     Tuple		=    tf.squeeze(ids_tensor((1, 1)     ,     self.model_tester.vocab_size       )     ,     0       ).numpy()[0]
     if token not in special_tokens:
       bad_tokens.append(_UpperCAmelCase       )
   return bad_tokens




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




 def 						a					( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase       ):
   # for all bad word tokens
   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(_UpperCAmelCase       )     ,     len(_UpperCAmelCase       )       ):
         # if tokens match
         if generated_ids_slice[i - len(_UpperCAmelCase       ) : 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    _snake_case		()       ->		Optional[int]:
  __UpperCAmelCase  :     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  :     str		=    getattr(transformers.models.auto						,					snake_case_						,					snake_case_     )
    if module is None:
      continue
    # all mappings in a single auto modeling file
    __UpperCAmelCase  :     Dict		=    [
        x
        for x in dir(snake_case_     )
        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  :     Optional[int]		=    getattr(snake_case_						,					snake_case_     )
      if mapping is not None:
        for v in mapping.values():
          if isinstance(snake_case_						,					(list, tuple)     ):
            model_names.update(snake_case_     )
          elif isinstance(snake_case_						,					snake_case_     ):
            model_names.add(snake_case_     )

  return sorted(snake_case_     )





def    _snake_case		()       ->		Any:
  # All model names defined in auto mappings
  __UpperCAmelCase  :     int		=    set(get_all_model_names()     )

  with open('tests/utils/tiny_model_summary.json'     ) as fp:
    __UpperCAmelCase  :     Tuple		=    json.load(snake_case_     )
  __UpperCAmelCase  :     int		=    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  :     Tuple		=    model_names.difference(snake_case_     )
  for model_name in copy.copy(snake_case_     ):
    if not model_name.startswith('TF'     ) and F"TF{model_name}" in not_on_hub:
      tiny_models_names.remove(snake_case_     )
    elif model_name.startswith('TF'     ) and model_name[2:] in not_on_hub:
      tiny_models_names.remove(snake_case_     )

  return sorted(snake_case_     )





def    _snake_case		(snake_case_				:    List[str]     )       ->		Tuple:
  __UpperCAmelCase  :     Dict		=    COMPOSITE_MODELS.values()

  # All tiny model base names on Hub
  __UpperCAmelCase  :     Optional[int]		=    get_all_model_names()
  __UpperCAmelCase  :     List[Any]		=    hf_api.list_models(
      filter=ModelFilter(
          author='hf-internal-testing'						,					)     )
  __UpperCAmelCase  :     Dict		=    set()
  for x in models:
    __UpperCAmelCase  :     Union[str, Any]		=    x.modelId
    __UpperCAmelCase, __UpperCAmelCase  :     List[str]		=    model.split('/'     )
    if not model.startswith('tiny-random-'     ):
      continue
    __UpperCAmelCase  :     Optional[Any]		=    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(snake_case_     )

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

    __UpperCAmelCase  :     str		=    content
    with open(os.path.join(snake_case_						,					'hub_tiny_model_summary.json'     )						,					'w'     ) as fp:
      json.dump(snake_case_						,					snake_case_						,					ensure_ascii=snake_case_						,					indent=4     )


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

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

      _SCREAMING_SNAKE_CASE          = '''tiny_models'''
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = None
      _SCREAMING_SNAKE_CASE          = get_tiny_model_names_from_repo()
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = '''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,
      )





