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       (							):
      A__       =    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"]:
          A__       =    getattr(transformers.models.auto		, _UpperCamelCase		, _UpperCamelCase )
          if module is None:
              continue
          # all mappings in a single auto modeling file
          A__       =    [
              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:
              A__       =    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       (							):
      A__       =    set(get_all_model_names() )
  
      with open("tests/utils/tiny_model_summary.json" ) as fp:
          A__       =    json.load(_UpperCamelCase )
      A__       =    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.
      A__       =    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       (							_lowerCamelCase      :      Optional[int] ):
      A__       =    COMPOSITE_MODELS.values()
  
      # All tiny model base names on Hub
      A__       =    get_all_model_names()
      A__       =    hf_api.list_models(
          filter=ModelFilter(
              author="hf-internal-testing"		, ) )
      A__       =    set()
      for x in models:
          A__       =    x.modelId
          A__,			A__       =    model.split("/" )
          if not model.startswith("tiny-random-" ):
              continue
          A__       =    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 )
  
      A__       =    sorted(_models )
      # All tiny model names on Hub
      A__       =    {}
      for model in models:
          A__       =    F"hf-internal-testing/tiny-random-{model}"
          A__       =    model.split("-" )[0]
          try:
              A__       =    hf_api.repo_info(_UpperCamelCase )
              A__       =    {
                  "tokenizer_classes": set(),
                  "processor_classes": set(),
                  "model_classes": set(),
                  "sha": repo_info.sha,
              }
          except Exception:
              continue
          try:
              time.sleep(1 )
              A__       =    AutoTokenizer.from_pretrained(_UpperCamelCase )
              content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__ )
          except Exception:
              pass
          try:
              time.sleep(1 )
              A__       =    AutoTokenizer.from_pretrained(_UpperCamelCase		, use_fast=_UpperCamelCase )
              content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__ )
          except Exception:
              pass
          try:
              time.sleep(1 )
              A__       =    AutoImageProcessor.from_pretrained(_UpperCamelCase )
              content["processor_classes"].add(img_p.__class__.__name__ )
          except Exception:
              pass
          try:
              time.sleep(1 )
              A__       =    AutoFeatureExtractor.from_pretrained(_UpperCamelCase )
              if not isinstance(_UpperCamelCase		, _UpperCamelCase ):
                  content["processor_classes"].add(feat_p.__class__.__name__ )
          except Exception:
              pass
          try:
              time.sleep(1 )
              A__       =    getattr(_UpperCamelCase		, _UpperCamelCase )
              A__       =    model_class.from_pretrained(_UpperCamelCase )
              content["model_classes"].add(m.__class__.__name__ )
          except Exception:
              pass
          try:
              time.sleep(1 )
              A__       =    getattr(_UpperCamelCase		, F"TF{model}" )
              A__       =    model_class.from_pretrained(_UpperCamelCase )
              content["model_classes"].add(m.__class__.__name__ )
          except Exception:
              pass
  
          A__       =    sorted(content["tokenizer_classes"] )
          A__       =    sorted(content["processor_classes"] )
          A__       =    sorted(content["model_classes"] )
  
          A__       =    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__":
    __lowerCAmelCase							:			str				=argparse.ArgumentParser()
    parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
    __lowerCAmelCase							:			Tuple				=parser.parse_args()
  
    # This has to be `spawn` to avoid hanging forever!
    multiprocessing.set_start_method("spawn")
  
    __lowerCAmelCase							:			List[str]				="tiny_models"
    __lowerCAmelCase							:			Union[str, Any]				=True
    __lowerCAmelCase							:			str				=None
    __lowerCAmelCase							:			Union[str, Any]				=get_tiny_model_names_from_repo()
    __lowerCAmelCase							:			Any				=True
    __lowerCAmelCase							:			Tuple				=True
    __lowerCAmelCase							:			Optional[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,
    )
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __lowerCAmelCase							:			int				={
      "configuration_layoutlm": ["LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "LayoutLMConfig", "LayoutLMOnnxConfig"],
      "tokenization_layoutlm": ["LayoutLMTokenizer"],
  }
  
  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __lowerCAmelCase							:			Any				=["LayoutLMTokenizerFast"]
  
  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __lowerCAmelCase							:			Dict				=[
        "LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST",
        "LayoutLMForMaskedLM",
        "LayoutLMForSequenceClassification",
        "LayoutLMForTokenClassification",
        "LayoutLMForQuestionAnswering",
        "LayoutLMModel",
        "LayoutLMPreTrainedModel",
    ]
  
  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __lowerCAmelCase							:			str				=[
        "TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST",
        "TFLayoutLMForMaskedLM",
        "TFLayoutLMForSequenceClassification",
        "TFLayoutLMForTokenClassification",
        "TFLayoutLMForQuestionAnswering",
        "TFLayoutLMMainLayer",
        "TFLayoutLMModel",
        "TFLayoutLMPreTrainedModel",
    ]
  
  
  if TYPE_CHECKING:
    from .configuration_layoutlm import LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMConfig, LayoutLMOnnxConfig
    from .tokenization_layoutlm import LayoutLMTokenizer
  
    try:
      if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .tokenization_layoutlm_fast import LayoutLMTokenizerFast
  
    try:
      if not is_torch_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_layoutlm import (
          LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          LayoutLMForMaskedLM,
          LayoutLMForQuestionAnswering,
          LayoutLMForSequenceClassification,
          LayoutLMForTokenClassification,
          LayoutLMModel,
          LayoutLMPreTrainedModel,
      )
    try:
      if not is_tf_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_tf_layoutlm import (
          TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForQuestionAnswering,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForTokenClassification,
          TFLayoutLMMainLayer,
          TFLayoutLMModel,
          TFLayoutLMPreTrainedModel,
      )
  
  else:
    import sys
  
    __lowerCAmelCase							:			int				=_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
  
  