





'''simple docstring'''

from collections import Counter







def 						snake_case__	(      UpperCamelCase	) ->      int:
		return sum(socks_by_color // 2 for socks_by_color in Counter(UpperCamelCase	).values()	)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	_UpperCAmelCase   :      Tuple 						=  [int(x) for x in input("""Enter socks by color :""").rstrip().split()]
	print(f"""sock_merchant({colors}) = {sock_merchant(colors)}""")







'''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 						snake_case__	(      ) ->      List[Any]:
		_UpperCamelCase       : 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"]:
				_UpperCamelCase       : List[Any]    =      getattr(transformers.models.auto			,UpperCamelCase			,UpperCamelCase	)
				if module is None:
						continue
				# all mappings in a single auto modeling file
				_UpperCamelCase       : Optional[Any]    =      [
				    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:
						_UpperCamelCase       : List[str]    =      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 						snake_case__	(      ) ->      Any:
		# All model names defined in auto mappings
		_UpperCamelCase       : Union[str, Any]    =      set(get_all_model_names()	)

		with open('''tests/utils/tiny_model_summary.json'''	) as fp:
				_UpperCamelCase       : Optional[Any]    =      json.load(UpperCamelCase	)
		_UpperCamelCase       : Tuple    =      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       : List[Any]    =      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 						snake_case__	(      UpperCamelCase	) ->      List[str]:
		_UpperCamelCase       : Optional[Any]    =      COMPOSITE_MODELS.values()

		# All tiny model base names on Hub
		_UpperCamelCase       : Optional[Any]    =      get_all_model_names()
		_UpperCamelCase       : Union[str, Any]    =      hf_api.list_models(
		    filter=ModelFilter(
		        author='''hf-internal-testing'''			,)	)
		_UpperCamelCase       : Any    =      set()
		for x in models:
				_UpperCamelCase       : Optional[int]    =      x.modelId
				_UpperCamelCase,							_UpperCamelCase       : 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(UpperCamelCase	)

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

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

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

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

	_UpperCAmelCase   :      Optional[Any] 						=  """tiny_models"""
	_UpperCAmelCase   :      Optional[Any] 						=  True
	_UpperCAmelCase   :      str 						=  None
	_UpperCAmelCase   :      int 						=  get_tiny_model_names_from_repo()
	_UpperCAmelCase   :      Optional[Any] 						=  True
	_UpperCAmelCase   :      List[str] 						=  True
	_UpperCAmelCase   :      str 						=  """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,
	)





