


'''simple docstring'''




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

import yaml



class  lowerCAmelCase				(				yaml.SafeLoader							):



	def 				lowercase     (					self ,					snake_case__    ):
		lowerCAmelCase					:    Union[str, Any]      							= [self.constructed_objects[key_node] for key_node, _ in node.value]
		lowerCAmelCase					:    Dict      							= [tuple(snake_case__    ) if isinstance(snake_case__ ,					snake_case__    ) else key for key in keys]
		lowerCAmelCase					:    Union[str, Any]      							= Counter(snake_case__    )
		lowerCAmelCase					:    Union[str, Any]      							= [key for key in counter if counter[key] > 1]
		if duplicate_keys:
			raise TypeError(f"Got duplicate yaml keys: {duplicate_keys}"    )



	def 				lowercase     (					self ,					snake_case__ ,					snake_case__=False    ):
		lowerCAmelCase					:    Tuple      							= super().construct_mapping(snake_case__ ,					deep=snake_case__    )
		self._check_no_duplicates_on_constructed_node(snake_case__    )
		return mapping


def 			__UpperCamelCase    (    _A    :				str				)    ->      Tuple[Optional[str], str]:




	"""simple docstring"""





	lowerCAmelCase					:    Dict      							= list(readme_content.splitlines()				)
	if full_content and full_content[0] == "---" and "---" in full_content[1:]:
		lowerCAmelCase					:    List[Any]      							= full_content[1:].index('---'				) + 1
		lowerCAmelCase					:    Tuple      							= '\n'.join(full_content[1:sep_idx]				)
		return yamlblock, "\n".join(full_content[sep_idx + 1 :]				)

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



class  lowerCAmelCase				(				a							):
	# class attributes
	_lowerCamelCase   :					int			      = {"""train_eval_index"""}  # train-eval-index in the YAML metadata



	@classmethod
	def 				lowercase     (					cls ,					snake_case__    ):
		with open(snake_case__ ,					encoding='utf-8'    ) as readme_file:
			lowerCAmelCase					:    Tuple      							= _split_yaml_from_readme(readme_file.read()    )
		if yaml_string is not None:
			return cls.from_yaml_string(snake_case__    )
		else:
			return cls()



	def 				lowercase     (					self ,					snake_case__    ):
		if path.exists():
			with open(snake_case__ ,					encoding='utf-8'    ) as readme_file:
				lowerCAmelCase					:    str      							= readme_file.read()
		else:
			lowerCAmelCase					:    Optional[Any]      							= None
		lowerCAmelCase					:    Any      							= self._to_readme(snake_case__    )
		with open(snake_case__ ,					'w' ,					encoding='utf-8'    ) as readme_file:
			readme_file.write(snake_case__    )



	def 				lowercase     (					self ,					snake_case__ = None    ):
		if readme_content is not None:
			lowerCAmelCase					:    Tuple      							= _split_yaml_from_readme(snake_case__    )
			lowerCAmelCase					:    Optional[int]      							= '---\n' + self.to_yaml_string() + '---\n' + content
		else:
			lowerCAmelCase					:    List[str]      							= '---\n' + self.to_yaml_string() + '---\n'
		return full_content



	@classmethod
	def 				lowercase     (					cls ,					snake_case__    ):
		lowerCAmelCase					:    Dict      							= yaml.load(snake_case__ ,					Loader=_NoDuplicateSafeLoader    ) or {}

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



	def 				lowercase     (					self    ):
		return yaml.safe_dump(
		    {
		        (key.replace('_' ,					'-'    ) if key in self._FIELDS_WITH_DASHES else key): value
		        for key, value in self.items()
		    } ,					sort_keys=snake_case__ ,					allow_unicode=snake_case__ ,					encoding='utf-8' ,					).decode('utf-8'    )


_lowerCAmelCase  :		int		     =	{
    '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

	_lowerCAmelCase  :		str		     =	ArgumentParser(usage='Validate the yaml metadata block of a README.md file.')
	ap.add_argument('readme_filepath')
	_lowerCAmelCase  :		Optional[int]		     =	ap.parse_args()

	_lowerCAmelCase  :		Dict		     =	Path(args.readme_filepath)
	_lowerCAmelCase  :		Optional[int]		     =	DatasetMetadata.from_readme(readme_filepath)
	print(dataset_metadata)
	dataset_metadata.to_readme(readme_filepath)




'''simple docstring'''




def 			__UpperCamelCase    (    _A    :				int				)    ->      bool:




	"""simple docstring"""





	return number & 1 == 0


if __name__ == "__main__":
				import doctest

				doctest.testmod()
