
'''simple docstring'''


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

import yaml

class 						__lowercase					(	yaml.SafeLoader     ):

			def 							UpperCAmelCase__			(self      , A   ):
								lowerCamelCase_       :   Tuple  =		[self.constructed_objects[key_node] for key_node, _ in node.value]
								lowerCamelCase_       :   List[Any]  =		[tuple(_lowercase   ) if isinstance(_lowercase      , _lowercase   ) else key for key in keys]
								lowerCamelCase_       :   List[str]  =		Counter(_lowercase   )
								lowerCamelCase_       :   Any  =		[key for key in counter if counter[key] > 1]
								if duplicate_keys:
													raise TypeError(F"""Got duplicate yaml keys: {duplicate_keys}"""   )






			def 							UpperCAmelCase__			(self      , A      , A=False   ):
								lowerCamelCase_       :   Optional[int]  =		super().construct_mapping(_lowercase      , deep=_lowercase   )
								self._check_no_duplicates_on_constructed_node(_lowercase   )
								return mapping




def lowercase_						( _lowercase					)  ->				Tuple:
					'''simple docstring'''

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

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

class 						__lowercase					(	SCREAMING_SNAKE_CASE__     ):
			# class attributes
			lowerCamelCase      :		Tuple						   =      {"train_eval_index"}  # train-eval-index in the YAML metadata

			@classmethod
			def 							UpperCAmelCase__			(cls      , A   ):
								with open(_lowercase      , 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(_lowercase   )
								else:
													return cls()

			def 							UpperCAmelCase__			(self      , A   ):
								if path.exists():
													with open(_lowercase      , encoding='''utf-8'''   ) as readme_file:
																		lowerCamelCase_       :   Any  =		readme_file.read()
								else:
													lowerCamelCase_       :   List[str]  =		None
								lowerCamelCase_       :   Optional[Any]  =		self._to_readme(_lowercase   )
								with open(_lowercase      , '''w'''      , encoding='''utf-8'''   ) as readme_file:
													readme_file.write(_lowercase   )

			def 							UpperCAmelCase__			(self      , A = None   ):
								if readme_content is not None:
													lowerCamelCase_       :   Any  =		_split_yaml_from_readme(_lowercase   )
													lowerCamelCase_       :   Union[str, Any]  =		"---\n" + self.to_yaml_string() + "---\n" + content
								else:
													lowerCamelCase_       :   int  =		"---\n" + self.to_yaml_string() + "---\n"
								return full_content

			@classmethod
			def 							UpperCAmelCase__			(cls      , A   ):
								lowerCamelCase_       :   int  =		yaml.load(_lowercase      , Loader=_NoDuplicateSafeLoader   ) or {}

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






			def 							UpperCAmelCase__			(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=_lowercase      , allow_unicode=_lowercase      , encoding='''utf-8'''      , ).decode('''utf-8'''   )
__lowercase				: Dict											=  {
    '''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				: Tuple											=  ArgumentParser(usage='''Validate the yaml metadata block of a README.md file.''')
					ap.add_argument('''readme_filepath''')
					__lowercase				: List[Any]											=  ap.parse_args()

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







"""simple docstring"""







A		=						8.31_4462  # Unit - J mol-1 K-1

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							float     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							float ):
						"""simple docstring"""






						if moles < 0 or kelvin < 0 or volume < 0:
												raise ValueError("Invalid inputs. Enter positive value." )
						return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							float     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							float ):
						"""simple docstring"""






						if moles < 0 or kelvin < 0 or pressure < 0:
												raise ValueError("Invalid inputs. Enter positive value." )
						return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure


if __name__ == "__main__":
			from doctest import testmod

			testmod()



