
'''simple docstring'''





from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available





def 							snake_case				(		UpperCAmelCase						)->      str:







      """simple docstring"""
      if is_torch_available():
            import torch

            if isinstance(UpperCAmelCase   ,	torch.Tensor						):
                  return True

      return isinstance(UpperCAmelCase   ,	np.ndarray						)


class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE):






 def 						lowercase_    (      self	:Optional[Any]      )					->      Tuple:







       '''simple docstring'''



       __A													=      fields(self      )

       # Safety and consistency checks
       if not len(_A      ):
             raise ValueError(F'{self.__class__.__name__} has no fields.'      )

       __A													=      getattr(self						,					class_fields[0].name      )
       __A													=      all(getattr(self						,					field.name      ) is None for field in class_fields[1:]      )

       if other_fields_are_none and isinstance(_A						,					_A      ):
             for key, value in first_field.items():
                   __A													=      value
       else:
             for field in class_fields:
                   __A													=      getattr(self						,					field.name      )
                   if v is not None:
                         __A													=      v






 def __delitem__(      self	:Optional[Any]						,					*_A	:Tuple						,					**_A	:Optional[Any]      )					->      str:







       '''simple docstring'''



       raise Exception(F'You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.'      )






 def 						lowercase_    (      self	:Any						,					*_A	:Tuple						,					**_A	:Any      )					->      List[Any]:







       '''simple docstring'''



       raise Exception(F'You cannot use ``setdefault`` on a {self.__class__.__name__} instance.'      )






 def 						lowercase_    (      self	:List[Any]						,					*_A	:Tuple						,					**_A	:List[Any]      )					->      int:







       '''simple docstring'''



       raise Exception(F'You cannot use ``pop`` on a {self.__class__.__name__} instance.'      )






 def 						lowercase_    (      self	:List[str]						,					*_A	:Union[str, Any]						,					**_A	:Union[str, Any]      )					->      Any:







       '''simple docstring'''



       raise Exception(F'You cannot use ``update`` on a {self.__class__.__name__} instance.'      )






 def __getitem__(      self	:Optional[Any]						,					_A	:Union[str, Any]      )					->      Dict:







       '''simple docstring'''



       if isinstance(_A						,					_A      ):
             __A													=      dict(self.items()      )
             return inner_dict[k]
       else:
             return self.to_tuple()[k]






 def __setattr__(      self	:str						,					_A	:Any						,					_A	:str      )					->      Union[str, Any]:







       '''simple docstring'''



       if name in self.keys() and value is not None:
             # Don't call self.__setitem__ to avoid recursion errors
             super().__setitem__(_A						,					_A      )
       super().__setattr__(_A						,					_A      )






 def __setitem__(      self	:List[str]						,					_A	:Tuple						,					_A	:List[Any]      )					->      int:







       '''simple docstring'''



       super().__setitem__(_A						,					_A      )
       # Don't call self.__setattr__ to avoid recursion errors
       super().__setattr__(_A						,					_A      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      Tuple[Any]:







       '''simple docstring'''



       return tuple(self[k] for k in self.keys()      )











"""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   A_    (     ):







						'''simple docstring'''


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

						return sorted(_lowercase      )
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:List[str]		=     set(get_all_model_names()      )

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

						return sorted(_lowercase      )
def   A_    (     _lowercase      ):







						'''simple docstring'''


						snake_case_					:Tuple		=     COMPOSITE_MODELS.values()

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

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

												snake_case_					:Union[str, Any]		=     sorted(content["""tokenizer_classes"""]      )
												snake_case_					:Dict		=     sorted(content["""processor_classes"""]      )
												snake_case_					:List[str]		=     sorted(content["""model_classes"""]      )

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