

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

		return sorted(snake_case_     )





def    _snake_case		()       ->		Any:
		# All model names defined in auto mappings
		__UpperCAmelCase  :     int		=    set(get_all_model_names()     )

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

		return sorted(snake_case_     )





def    _snake_case		(snake_case_				:    List[str]     )       ->		Tuple:
		__UpperCAmelCase  :     Dict		=    COMPOSITE_MODELS.values()

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

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

				__UpperCAmelCase  :     Optional[int]		=    sorted(content['tokenizer_classes']     )
				__UpperCAmelCase  :     List[str]		=    sorted(content['processor_classes']     )
				__UpperCAmelCase  :     Tuple		=    sorted(content['model_classes']     )

				__UpperCAmelCase  :     str		=    content
				with open(os.path.join(snake_case_						,					'hub_tiny_model_summary.json'     )						,					'w'     ) as fp:
						json.dump(snake_case_						,					snake_case_						,					ensure_ascii=snake_case_						,					indent=4     )


if __name__ == "__main__":
						_SCREAMING_SNAKE_CASE          = argparse.ArgumentParser()
						parser.add_argument('''--num_workers''', default=1, type=int, help='''The number of workers to run.''')
						_SCREAMING_SNAKE_CASE          = parser.parse_args()

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

						_SCREAMING_SNAKE_CASE          = '''tiny_models'''
						_SCREAMING_SNAKE_CASE          = True
						_SCREAMING_SNAKE_CASE          = None
						_SCREAMING_SNAKE_CASE          = get_tiny_model_names_from_repo()
						_SCREAMING_SNAKE_CASE          = True
						_SCREAMING_SNAKE_CASE          = True
						_SCREAMING_SNAKE_CASE          = '''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,
						)








import math
from itertools import permutations





def    _snake_case		(snake_case_				:    int     )       ->		bool:

  if 1 < number < 4:
    # 2 and 3 are primes
    return True
  elif number < 2 or number % 2 == 0 or number % 3 == 0:
    # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
    return False

  # All primes number are in format of 6k +/- 1
  for i in range(5						,					int(math.sqrt(snake_case_     ) + 1     )						,					6     ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True





def    _snake_case		(snake_case_				:    int						,					snake_case_				:    list     )       ->		bool:
  __UpperCAmelCase, __UpperCAmelCase  :     Any		=    0, len(snake_case_     ) - 1
  while left <= right:
    __UpperCAmelCase  :     List[str]		=    (left + right) // 2
    if prime_list[middle] == target:
      return True
    elif prime_list[middle] < target:
      __UpperCAmelCase  :     Tuple		=    middle + 1
    else:
      __UpperCAmelCase  :     Tuple		=    middle - 1

  return False





def    _snake_case		()       ->		str:
  __UpperCAmelCase  :     List[Any]		=    [n for n in range(1001						,					1_0000						,					2     ) if is_prime(snake_case_     )]
  __UpperCAmelCase  :     Tuple		=    []

  for number in prime_list:
    __UpperCAmelCase  :     List[str]		=    []

    for prime_member in permutations(list(str(snake_case_     )     )     ):
      __UpperCAmelCase  :     Dict		=    int(''.join(snake_case_     )     )

      if prime % 2 == 0:
        continue

      if search(snake_case_						,					snake_case_     ):
        tmp_numbers.append(snake_case_     )

    tmp_numbers.sort()
    if len(snake_case_     ) >= 3:
      candidates.append(snake_case_     )

  __UpperCAmelCase  :     Optional[int]		=    []
  for candidate in candidates:
    __UpperCAmelCase  :     int		=    len(snake_case_     )
    __UpperCAmelCase  :     List[Any]		=    False

    for i in range(snake_case_     ):
      for j in range(i + 1						,					snake_case_     ):
        for k in range(j + 1						,					snake_case_     ):
          if (
              abs(candidate[i] - candidate[j]     )
              == abs(candidate[j] - candidate[k]     )
              and len({candidate[i], candidate[j], candidate[k]}     ) == 3
          ):
            passed.append(
                sorted([candidate[i], candidate[j], candidate[k]]     )     )
            __UpperCAmelCase  :     Any		=    True

          if found:
            break
        if found:
          break
      if found:
        break

  __UpperCAmelCase  :     Dict		=    set()
  for seq in passed:
    answer.add(''.join([str(snake_case_     ) for i in seq]     )     )

  return max(int(snake_case_     ) for x in answer     )


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





