
'''simple docstring'''







from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml


class 						__UpperCAmelCase      (					yaml.SafeLoader						):


							def  lowerCamelCase				(       self    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								_snake_case   						=		[self.constructed_objects[key_node] for key_node, _ in node.value]
								_snake_case   						=		[tuple(SCREAMING_SNAKE_CASE__  ) if isinstance(SCREAMING_SNAKE_CASE__    ,   SCREAMING_SNAKE_CASE__  ) else key for key in keys]
								_snake_case   						=		Counter(SCREAMING_SNAKE_CASE__  )
								_snake_case   						=		[key for key in counter if counter[key] > 1]
								if duplicate_keys:
									raise TypeError(F'Got duplicate yaml keys: {duplicate_keys}'  )




							def  lowerCamelCase				(       self    ,   lowerCAmelCase_    ,   lowerCAmelCase_=False  ):





								"""simple docstring"""






								_snake_case   						=		super().construct_mapping(SCREAMING_SNAKE_CASE__    ,   deep=SCREAMING_SNAKE_CASE__  )
								self._check_no_duplicates_on_constructed_node(SCREAMING_SNAKE_CASE__  )
								return mapping







def 				SCREAMING_SNAKE_CASE__	(   __A	)       ->	Tuple[Optional[str], str]:
	_snake_case   						=		list(readme_content.splitlines()	)
	if full_content and full_content[0] == "---" and "---" in full_content[1:]:
		_snake_case   						=		full_content[1:].index('---'	) + 1
		_snake_case   						=		'''\n'''.join(full_content[1:sep_idx]	)
		return yamlblock, "\n".join(full_content[sep_idx + 1 :]	)

	return None, "\n".join(a_	)


class 						__UpperCAmelCase      (					_lowerCamelCase						):
							# class attributes
							__lowercase      		=       {'''train_eval_index'''}  # train-eval-index in the YAML metadata


							@classmethod
							def  lowerCamelCase				(       cls    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								with open(SCREAMING_SNAKE_CASE__    ,   encoding='utf-8'  ) as readme_file:
									_snake_case   						=		_split_yaml_from_readme(readme_file.read()  )
								if yaml_string is not None:
									return cls.from_yaml_string(SCREAMING_SNAKE_CASE__  )
								else:
									return cls()


							def  lowerCamelCase				(       self    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								if path.exists():
									with open(SCREAMING_SNAKE_CASE__    ,   encoding='utf-8'  ) as readme_file:
										_snake_case   						=		readme_file.read()
								else:
									_snake_case   						=		None
								_snake_case   						=		self._to_readme(SCREAMING_SNAKE_CASE__  )
								with open(SCREAMING_SNAKE_CASE__    ,   'w'    ,   encoding='utf-8'  ) as readme_file:
									readme_file.write(SCREAMING_SNAKE_CASE__  )


							def  lowerCamelCase				(       self    ,   lowerCAmelCase_ = None  ):





								"""simple docstring"""






								if readme_content is not None:
									_snake_case   						=		_split_yaml_from_readme(SCREAMING_SNAKE_CASE__  )
									_snake_case   						=		'''---\n''' + self.to_yaml_string() + '''---\n''' + content
								else:
									_snake_case   						=		'''---\n''' + self.to_yaml_string() + '''---\n'''
								return full_content


							@classmethod
							def  lowerCamelCase				(       cls    ,   lowerCAmelCase_  ):





								"""simple docstring"""






								_snake_case   						=		yaml.load(SCREAMING_SNAKE_CASE__    ,   Loader=_NoDuplicateSafeLoader  ) or {}

								# Convert the YAML keys to DatasetMetadata fields
								_snake_case   						=		{
								    (key.replace('-'    ,   '_'  ) if key.replace('-'    ,   '_'  ) in cls._FIELDS_WITH_DASHES else key): value
								    for key, value in metadata_dict.items()
								}
								return cls(**SCREAMING_SNAKE_CASE__  )




							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






								return yaml.safe_dump(
								    {
								        (key.replace('_'    ,   '-'  ) if key in self._FIELDS_WITH_DASHES else key): value
								        for key, value in self.items()
								    }    ,   sort_keys=SCREAMING_SNAKE_CASE__    ,   allow_unicode=SCREAMING_SNAKE_CASE__    ,   encoding='utf-8'    ,   ).decode('utf-8'  )
lowercase    :							List[str]      =					{
    "image-classification": [],
    "translation": [],
    "image-segmentation": [],
    "fill-mask": [],
    "automatic-speech-recognition": [],
    "token-classification": [],
    "sentence-similarity": [],
    "audio-classification": [],
    "question-answering": [],
    "summarization": [],
    "zero-shot-classification": [],
    "table-to-text": [],
    "feature-extraction": [],
    "other": [],
    "multiple-choice": [],
    "text-classification": [],
    "text-to-image": [],
    "text2text-generation": [],
    "zero-shot-image-classification": [],
    "tabular-classification": [],
    "tabular-regression": [],
    "image-to-image": [],
    "tabular-to-text": [],
    "unconditional-image-generation": [],
    "text-retrieval": [],
    "text-to-speech": [],
    "object-detection": [],
    "audio-to-audio": [],
    "text-generation": [],
    "conversational": [],
    "table-question-answering": [],
    "visual-question-answering": [],
    "image-to-text": [],
    "reinforcement-learning": [],
    "voice-activity-detection": [],
    "time-series-forecasting": [],
    "document-question-answering": [],
}


if __name__ == "__main__":
					from argparse import ArgumentParser

					lowercase    :							Optional[Any]      =					ArgumentParser(usage="Validate the yaml metadata block of a README.md file.")
					ap.add_argument("readme_filepath")
					lowercase    :							Dict      =					ap.parse_args()

					lowercase    :							List[str]      =					Path(args.readme_filepath)
					lowercase    :							List[str]      =					DatasetMetadata.from_readme(readme_filepath)
					print(dataset_metadata)
					dataset_metadata.to_readme(readme_filepath)








"""simple docstring"""
from typing import Any



def      __lowerCamelCase   (							a_     :		list							)			->      list[Any]:
      if not input_list:
            return []
      __SCREAMING_SNAKE_CASE   :int						=  [input_list.count(a_							) for value in input_list]
      __SCREAMING_SNAKE_CASE   :str						=  max(a_							)  # Gets the maximum count in the input list.
      # Gets values of modes
      return sorted({input_list[i] for i, value in enumerate(a_							) if value == y}							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()