




'''simple docstring'''
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_       (		):
    """simple docstring"""






    snake_case_	:      Union[str, 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"]:
        snake_case_	:      Tuple            =  getattr(transformers.models.auto,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE    )
        if module is None:
            continue
        # all mappings in a single auto modeling file
        snake_case_	:      Union[str, Any]            =  [
            x
            for x in dir(__SCREAMING_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:
            snake_case_	:      List[str]            =  getattr(__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE    )
            if mapping is not None:
                for v in mapping.values():
                    if isinstance(__SCREAMING_SNAKE_CASE,						(list, tuple)    ):
                        model_names.update(__SCREAMING_SNAKE_CASE    )
                    elif isinstance(__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE    ):
                        model_names.add(__SCREAMING_SNAKE_CASE    )

    return sorted(__SCREAMING_SNAKE_CASE    )

def   UpperCamelCase_       (		):
    """simple docstring"""






    snake_case_	:      str            =  set(get_all_model_names()    )

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

    return sorted(__SCREAMING_SNAKE_CASE    )

def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE    ):
    """simple docstring"""






    snake_case_	:      int            =  COMPOSITE_MODELS.values()

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

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

        snake_case_	:      Any            =  sorted(content["tokenizer_classes"]    )
        snake_case_	:      Any            =  sorted(content["processor_classes"]    )
        snake_case_	:      int            =  sorted(content["model_classes"]    )

        snake_case_	:      int            =  content
        with open(os.path.join(__SCREAMING_SNAKE_CASE,						"hub_tiny_model_summary.json"    ),						"w"    ) as fp:
            json.dump(__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						ensure_ascii=__SCREAMING_SNAKE_CASE,						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,
  )






'''simple docstring'''
def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE    ):
    """simple docstring"""






    snake_case_	:      Optional[int]            =  len(__SCREAMING_SNAKE_CASE    )

    # Set the gap value to be decreased by a factor of 1.3
    # after each iteration
    snake_case_	:      Optional[int]            =  1.3

    # Continue sorting until the gap is 1
    while gap > 1:
        # Decrease the gap value
        snake_case_	:      Optional[Any]            =  int(gap / shrink    )

        # Sort the elements using insertion sort
        for i in range(__SCREAMING_SNAKE_CASE,						len(__SCREAMING_SNAKE_CASE    )    ):
            snake_case_	:      Any            =  collection[i]
            snake_case_	:      int            =  i
            while j >= gap and collection[j - gap] > temp:
                snake_case_	:      Dict            =  collection[j - gap]
                j -= gap
            snake_case_	:      Optional[int]            =  temp

    return collection


if __name__ == "__main__":
  import doctest

  doctest.testmod()




