code: 
  
  
  """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_   (  ):
  			__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, lowercase__, lowercase__    )
  						if module is None:
  									continue
  						# all mappings in a single auto modeling file
  						__lowerCamelCase        =			[
  						    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:
  									__lowerCamelCase        =			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_   (  ):
  			# 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(lowercase__    )
  			__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(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__   :Tuple    ):
  			__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(lowercase__    )
  
  			__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(lowercase__    )
  									__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(lowercase__    )
  									content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__    )
  						except Exception:
  									pass
  						try:
  									time.sleep(1    )
  									__lowerCamelCase        =			AutoTokenizer.from_pretrained(lowercase__, use_fast=lowercase__    )
  									content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__    )
  						except Exception:
  									pass
  						try:
  									time.sleep(1    )
  									__lowerCamelCase        =			AutoImageProcessor.from_pretrained(lowercase__    )
  									content["processor_classes"].add(img_p.__class__.__name__    )
  						except Exception:
  									pass
  						try:
  									time.sleep(1    )
  									__lowerCamelCase        =			AutoFeatureExtractor.from_pretrained(lowercase__    )
  									if not isinstance(lowercase__, lowercase__    ):
  												content["processor_classes"].add(feat_p.__class__.__name__    )
  						except Exception:
  									pass
  						try:
  									time.sleep(1    )
  									__lowerCamelCase        =			getattr(lowercase__, lowercase__    )
  									__lowerCamelCase        =			model_class.from_pretrained(lowercase__    )
  									content["model_classes"].add(m.__class__.__name__    )
  						except Exception:
  									pass
  						try:
  									time.sleep(1    )
  									__lowerCamelCase        =			getattr(lowercase__, f'TF{model}'    )
  									__lowerCamelCase        =			model_class.from_pretrained(lowercase__    )
  									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(lowercase__, """hub_tiny_model_summary.json"""    ), """w"""    ) as fp:
  									json.dump(lowercase__, lowercase__, ensure_ascii=lowercase__, indent=4    )
  
  
  if __name__ == "__main__":
  					__magic_name__	:   str          =							argparse.ArgumentParser()
  					parser.add_argument('--num_workers', default=1, type=int, help='The number of workers to run.')
  					__magic_name__	:   int          =							parser.parse_args()
  
  					# This has to be `spawn` to avoid hanging forever!
  					multiprocessing.set_start_method('spawn')
  
  					__magic_name__	:   Optional[Any]          =							'tiny_models'
  					__magic_name__	:   str          =							True
  					__magic_name__	:   Dict          =							None
  					__magic_name__	:   Optional[int]          =							get_tiny_model_names_from_repo()
  					__magic_name__	:   List[Any]          =							True
  					__magic_name__	:   List[str]          =							True
  					__magic_name__	:   int          =							'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,
  					)
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  def 			a_   (  lowercase__   :str, lowercase__   :int = 13    ):
  			__lowerCamelCase        =			""""""
  			for c in s:
  						if "A" <= c <= "Z":
  									out += chr(ord("""A"""    ) + (ord(lowercase__    ) - ord("""A"""    ) + n) % 26    )
  						elif "a" <= c <= "z":
  									out += chr(ord("""a"""    ) + (ord(lowercase__    ) - ord("""a"""    ) + n) % 26    )
  						else:
  									out += c
  			return out
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			input("""Enter message: """    )
  
  			__lowerCamelCase        =			dencrypt(lowercase__, 13    )
  			print("""Encryption:""", lowercase__    )
  
  			__lowerCamelCase        =			dencrypt(lowercase__, 13    )
  			print("""Decryption: """, lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  					main()
  
  
  
  
  