


"""simple docstring"""




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

import yaml
class 					__lowerCAmelCase					(   yaml.SafeLoader       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self							, _a      ):
				__a           =			[self.constructed_objects[key_node] for key_node, _ in node.value]
				__a           =			[tuple(_a      ) if isinstance(_a							, _a      ) else key for key in keys]
				__a           =			Counter(_a      )
				__a           =			[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      ):
				__a           =			super().construct_mapping(_a							, deep=_a      )
				self._check_no_duplicates_on_constructed_node(_a      )
				return mapping







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

		return None, "\n".join(lowerCAmelCase__			)
class 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		__UpperCAmelCase		:			Optional[Any]										=				{'train_eval_index'}  # train-eval-index in the YAML metadata

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

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

		def 			__UpperCAmelCase       (  self							, _a = None      ):
				if readme_content is not None:
						__a      ,     __a           =			_split_yaml_from_readme(_a      )
						__a           =			'''---\n''' + self.to_yaml_string() + '''---\n''' + content
				else:
						__a           =			'''---\n''' + self.to_yaml_string() + '''---\n'''
				return full_content

		@classmethod
		def 			__UpperCAmelCase       (  cls							, _a      ):
				__a           =			yaml.load(_a							, Loader=_NoDuplicateSafeLoader      ) or {}

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





		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=_a							, allow_unicode=_a							, encoding='''utf-8'''							, ).decode('''utf-8'''      )







lowercase_			     =  {
    "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_			     =  ArgumentParser(usage="Validate the yaml metadata block of a README.md file.")
				ap.add_argument("readme_filepath")
				lowercase_			     =  ap.parse_args()

				lowercase_			     =  Path(args.readme_filepath)
				lowercase_			     =  DatasetMetadata.from_readme(readme_filepath)
				print(dataset_metadata)
				dataset_metadata.to_readme(readme_filepath)










"""simple docstring"""




lowercase_			     =  [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
lowercase_			     =  [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
lowercase_			     =  {
    0: "Sunday",
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday",
    4: "Thursday",
    5: "Friday",
    6: "Saturday",
}

def        lowercase							(		lowerCAmelCase__ :     int    ,					lowerCAmelCase__ :     int    ,					lowerCAmelCase__ :     int			) ->      str:
		assert len(str(lowerCAmelCase__			)			) > 2, "year should be in YYYY format"
		assert 1 <= month <= 12, "month should be between 1 to 12"
		assert 1 <= day <= 31, "day should be between 1 to 31"

		# Doomsday algorithm:
		__a           =			year // 100
		__a           =			(5 * (century % 4) + 2) % 7
		__a           =			year % 100
		__a           =			centurian % 12
		__a           =			(
		    (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
		) % 7
		__a           =			(
		    DOOMSDAY_NOT_LEAP[month - 1]
		    if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
		    else DOOMSDAY_LEAP[month - 1]
		)
		__a           =			(dooms_day + day - day_anchor) % 7
		return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
				import doctest

				doctest.testmod()






