
"""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     _lowerCamelCase()				-> Tuple:
	_lowerCAmelCase								=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								=getattr(transformers.models.auto    , __UpperCamelCase    , __UpperCamelCase       )
		if module is None:
			continue
		# all mappings in a single auto modeling file
		_lowerCAmelCase								=[
		    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:
			_lowerCAmelCase								=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     _lowerCamelCase()				-> List[str]:
	# All model names defined in auto mappings
	_lowerCAmelCase								=set(get_all_model_names()       )

	with open("""tests/utils/tiny_model_summary.json"""       ) as fp:
		_lowerCAmelCase								=json.load(__UpperCamelCase       )
	_lowerCAmelCase								=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								=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     _lowerCamelCase(__UpperCamelCase       )				-> Optional[Any]:
	_lowerCAmelCase								=COMPOSITE_MODELS.values()

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

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

		_lowerCAmelCase								=sorted(content["""tokenizer_classes"""]       )
		_lowerCAmelCase								=sorted(content["""processor_classes"""]       )
		_lowerCAmelCase								=sorted(content["""model_classes"""]       )

		_lowerCAmelCase								=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,
			)





"""simple docstring"""


import itertools



def     _lowerCamelCase(__UpperCamelCase       )				-> List[str]:
	return (
	    int("""""".join(combination[0:2]       )       ) * int("""""".join(combination[2:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	) or (
	    int("""""".join(combination[0]       )       ) * int("""""".join(combination[1:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	)



def     _lowerCamelCase()				-> Dict:
	return sum(
	    {
	        int("""""".join(pandigital[5:9]       )       )
	        for pandigital in itertools.permutations("""123456789"""       )
	        if is_combination_valid(__UpperCamelCase       )
	    }       )


if __name__ == "__main__":
			print(solution())



