code: 
  
  
  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 							UpperCAmelCase				(     )->		Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					SCREAMING_SNAKE_CASE_	      =       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"]:
  										SCREAMING_SNAKE_CASE_	      =       getattr(transformers.models.auto				,UpperCAmelCase				,UpperCAmelCase      )
  										if module is None:
  															continue
  										# all mappings in a single auto modeling file
  										SCREAMING_SNAKE_CASE_	      =       [
  										    x
  										    for x in dir(UpperCAmelCase      )
  										    if x.endswith('''_MAPPING_NAMES'''      )
  										    and (x.startswith('''MODEL_'''      ) or x.startswith('''TF_MODEL_'''      ) or x.startswith('''FLAX_MODEL_'''      ))
  										]
  										for name in mapping_names:
  															SCREAMING_SNAKE_CASE_	      =       getattr(UpperCAmelCase				,UpperCAmelCase      )
  															if mapping is not None:
  																				for v in mapping.values():
  																									if isinstance(UpperCAmelCase				,(list, tuple)      ):
  																														model_names.update(UpperCAmelCase      )
  																									elif isinstance(UpperCAmelCase				,UpperCAmelCase      ):
  																														model_names.add(UpperCAmelCase      )
  
  					return sorted(UpperCAmelCase      )
  
  
  
  
  
  
  
  def 							UpperCAmelCase				(     )->		Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					SCREAMING_SNAKE_CASE_	      =       set(get_all_model_names()      )
  
  					with open('''tests/utils/tiny_model_summary.json'''      ) as fp:
  										SCREAMING_SNAKE_CASE_	      =       json.load(UpperCAmelCase      )
  					SCREAMING_SNAKE_CASE_	      =       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.
  					SCREAMING_SNAKE_CASE_	      =       model_names.difference(UpperCAmelCase      )
  					for model_name in copy.copy(UpperCAmelCase      ):
  										if not model_name.startswith('''TF'''      ) and f'''TF{model_name}''' in not_on_hub:
  															tiny_models_names.remove(UpperCAmelCase      )
  										elif model_name.startswith('''TF'''      ) and model_name[2:] in not_on_hub:
  															tiny_models_names.remove(UpperCAmelCase      )
  
  					return sorted(UpperCAmelCase      )
  
  
  
  
  
  
  
  def 							UpperCAmelCase				(     UpperCAmelCase      )->		Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					SCREAMING_SNAKE_CASE_	      =       COMPOSITE_MODELS.values()
  
  					# All tiny model base names on Hub
  					SCREAMING_SNAKE_CASE_	      =       get_all_model_names()
  					SCREAMING_SNAKE_CASE_	      =       hf_api.list_models(
  					    filter=ModelFilter(
  					        author='''hf-internal-testing'''				,)      )
  					SCREAMING_SNAKE_CASE_	      =       set()
  					for x in models:
  										SCREAMING_SNAKE_CASE_	      =       x.modelId
  										SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       model.split('''/'''      )
  										if not model.startswith('''tiny-random-'''      ):
  															continue
  										SCREAMING_SNAKE_CASE_	      =       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(UpperCAmelCase      )
  
  					SCREAMING_SNAKE_CASE_	      =       sorted(_models      )
  					# All tiny model names on Hub
  					SCREAMING_SNAKE_CASE_	      =       {}
  					for model in models:
  										SCREAMING_SNAKE_CASE_	      =       f'''hf-internal-testing/tiny-random-{model}'''
  										SCREAMING_SNAKE_CASE_	      =       model.split('''-'''      )[0]
  										try:
  															SCREAMING_SNAKE_CASE_	      =       hf_api.repo_info(UpperCAmelCase      )
  															SCREAMING_SNAKE_CASE_	      =       {
  															    '''tokenizer_classes''': set(),
  															    '''processor_classes''': set(),
  															    '''model_classes''': set(),
  															    '''sha''': repo_info.sha,
  															}
  										except Exception:
  															continue
  										try:
  															time.sleep(1      )
  															SCREAMING_SNAKE_CASE_	      =       AutoTokenizer.from_pretrained(UpperCAmelCase      )
  															content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__      )
  										except Exception:
  															pass
  										try:
  															time.sleep(1      )
  															SCREAMING_SNAKE_CASE_	      =       AutoTokenizer.from_pretrained(UpperCAmelCase				,use_fast=UpperCAmelCase      )
  															content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__      )
  										except Exception:
  															pass
  										try:
  															time.sleep(1      )
  															SCREAMING_SNAKE_CASE_	      =       AutoImageProcessor.from_pretrained(UpperCAmelCase      )
  															content["processor_classes"].add(img_p.__class__.__name__      )
  										except Exception:
  															pass
  										try:
  															time.sleep(1      )
  															SCREAMING_SNAKE_CASE_	      =       AutoFeatureExtractor.from_pretrained(UpperCAmelCase      )
  															if not isinstance(UpperCAmelCase				,UpperCAmelCase      ):
  																				content["processor_classes"].add(feat_p.__class__.__name__      )
  										except Exception:
  															pass
  										try:
  															time.sleep(1      )
  															SCREAMING_SNAKE_CASE_	      =       getattr(UpperCAmelCase				,UpperCAmelCase      )
  															SCREAMING_SNAKE_CASE_	      =       model_class.from_pretrained(UpperCAmelCase      )
  															content["model_classes"].add(m.__class__.__name__      )
  										except Exception:
  															pass
  										try:
  															time.sleep(1      )
  															SCREAMING_SNAKE_CASE_	      =       getattr(UpperCAmelCase				,f'''TF{model}'''      )
  															SCREAMING_SNAKE_CASE_	      =       model_class.from_pretrained(UpperCAmelCase      )
  															content["model_classes"].add(m.__class__.__name__      )
  										except Exception:
  															pass
  
  										SCREAMING_SNAKE_CASE_	      =       sorted(content['''tokenizer_classes''']      )
  										SCREAMING_SNAKE_CASE_	      =       sorted(content['''processor_classes''']      )
  										SCREAMING_SNAKE_CASE_	      =       sorted(content['''model_classes''']      )
  
  										SCREAMING_SNAKE_CASE_	      =       content
  										with open(os.path.join(UpperCAmelCase				,'''hub_tiny_model_summary.json'''      )				,'''w'''      ) as fp:
  															json.dump(UpperCAmelCase				,UpperCAmelCase				,ensure_ascii=UpperCAmelCase				,indent=4      )
  
  
  if __name__ == "__main__":
  		A_														=      argparse.ArgumentParser()
  		parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
  		A_														=      parser.parse_args()
  
  		# This has to be `spawn` to avoid hanging forever!
  		multiprocessing.set_start_method("spawn")
  
  		A_														=      "tiny_models"
  		A_														=      True
  		A_														=      None
  		A_														=      get_tiny_model_names_from_repo()
  		A_														=      True
  		A_														=      True
  		A_														=      "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,
  		)
  
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_sentencepiece_available,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  A_														=      {
      "configuration_switch_transformers": [
          "SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP",
          "SwitchTransformersConfig",
          "SwitchTransformersOnnxConfig",
      ]
  }
  
  try:
  		if not is_torch_available():
  				raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  		pass
  else:
  		A_														=      [
  		    "SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST",
  		    "SwitchTransformersEncoderModel",
  		    "SwitchTransformersForConditionalGeneration",
  		    "SwitchTransformersModel",
  		    "SwitchTransformersPreTrainedModel",
  		    "SwitchTransformersTop1Router",
  		    "SwitchTransformersSparseMLP",
  		]
  
  
  if TYPE_CHECKING:
  		from .configuration_switch_transformers import (
  		    SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
  		    SwitchTransformersConfig,
  		    SwitchTransformersOnnxConfig,
  		)
  
  		try:
  				if not is_torch_available():
  						raise OptionalDependencyNotAvailable()
  		except OptionalDependencyNotAvailable:
  				pass
  		else:
  				from .modeling_switch_transformers import (
  				    SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
  				    SwitchTransformersEncoderModel,
  				    SwitchTransformersForConditionalGeneration,
  				    SwitchTransformersModel,
  				    SwitchTransformersPreTrainedModel,
  				    SwitchTransformersSparseMLP,
  				    SwitchTransformersTopaRouter,
  				)
  
  
  else:
  		import sys
  
  		A_														=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
  