


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__     (  ):
 __lowerCamelCase		:							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"]:
  __lowerCamelCase		:							Tuple							=						getattr(transformers.models.auto			,       SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						)
  if module is None:
   continue
  # all mappings in a single auto modeling file
  __lowerCamelCase		:							Optional[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:
   __lowerCamelCase		:							Tuple							=						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__     (  ):
 __lowerCamelCase		:							str							=						set(get_all_model_names()						)

 with open('tests/utils/tiny_model_summary.json'						) as fp:
  __lowerCamelCase		:							Optional[int]							=						json.load(SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							Dict							=						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.
 __lowerCamelCase		:							Any							=						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__						):
 __lowerCamelCase		:							int							=						COMPOSITE_MODELS.values()

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

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

  __lowerCamelCase		:							Union[str, Any]							=						sorted(content['tokenizer_classes']						)
  __lowerCamelCase		:							Union[str, Any]							=						sorted(content['processor_classes']						)
  __lowerCamelCase		:							str							=						sorted(content['model_classes']						)

  __lowerCamelCase		:							Union[str, Any]							=						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__":
       lowercase_           =	argparse.ArgumentParser()
       parser.add_argument('--num_workers', default=1, type=int, help='The number of workers to run.')
       lowercase_           =	parser.parse_args()

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

       lowercase_           =	"""tiny_models"""
       lowercase_           =	True
       lowercase_           =	None
       lowercase_           =	get_tiny_model_names_from_repo()
       lowercase_           =	True
       lowercase_           =	True
       lowercase_           =	"""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"""



from doctest import testmod
from math import sqrt


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      int							)->						list:






     '''simple docstring'''



     UpperCAmelCase__		:  list[int]				=				[]
     if num < 1:
          return facs
     facs.append(1							)
     if num == 1:
          return facs
     facs.append(snake_case							)
     for i in range(2       , int(sqrt(snake_case							)							) + 1							):
          if num % i == 0:  # If i is a factor of num
               facs.append(snake_case							)
               UpperCAmelCase__		:  Any				=				num // i  # num//i is the other factor of num
               if d != i:  # If d and i are distinct
                    facs.append(snake_case							)  # we have found another factor
     facs.sort()
     return facs


if __name__ == "__main__":
 testmod(name="""factors_of_a_number""", verbose=True)


