





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

import yaml
class 			UpperCamelCase_		(  yaml.SafeLoader					):




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





def 						lowerCamelCase__     (     UpperCamelCase__			:       str						)			-> Tuple[Optional[str], str]:



					'''simple docstring'''




					_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(UpperCamelCase__						)
class 			UpperCamelCase_		(  _lowerCamelCase					):
					# class attributes
					lowerCAmelCase_							=	{'''train_eval_index'''}  # train-eval-index in the YAML metadata




					@classmethod
					def 	lowerCAmelCase			(		cls				,						lowerCAmelCase_  )		->							"DatasetMetadata":
										with open(lowerCAmelCase_				,						encoding='utf-8'  ) as readme_file:
															_snake_case							,     _snake_case									=				_split_yaml_from_readme(readme_file.read()  )
										if yaml_string is not None:
															return cls.from_yaml_string(lowerCAmelCase_  )
										else:
															return cls()




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_  )		->							List[Any]:
										if path.exists():
															with open(lowerCAmelCase_				,						encoding='utf-8'  ) as readme_file:
																				_snake_case									=				readme_file.read()
										else:
															_snake_case									=				None
										_snake_case									=				self._to_readme(lowerCAmelCase_  )
										with open(lowerCAmelCase_				,						'w'				,						encoding='utf-8'  ) as readme_file:
															readme_file.write(lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_ = None  )		->							str:
										if readme_content is not None:
															_snake_case							,     _snake_case									=				_split_yaml_from_readme(lowerCAmelCase_  )
															_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_  )		->							"DatasetMetadata":
										_snake_case									=				yaml.load(lowerCAmelCase_				,						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(**lowerCAmelCase_  )






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





UpperCAmelCase_      							=     {
    """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

					UpperCAmelCase_      							=     ArgumentParser(usage="""Validate the yaml metadata block of a README.md file.""")
					ap.add_argument("""readme_filepath""")
					UpperCAmelCase_      							=     ap.parse_args()

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










def 						lowerCamelCase__     (     UpperCamelCase__			:       list						)			-> list:



					'''simple docstring'''




					_snake_case									=				len(UpperCamelCase__						)
					for i in range(1       ,    UpperCamelCase__						):
										_snake_case									=				collection[i]
										_snake_case									=				0
										_snake_case									=				i - 1

										while low <= high:
															_snake_case									=				(low + high) // 2
															if val < collection[mid]:
																				_snake_case									=				mid - 1
															else:
																				_snake_case									=				mid + 1
										for j in range(UpperCamelCase__       ,    UpperCamelCase__       ,    -1						):
															_snake_case									=				collection[j - 1]
										_snake_case									=				val
					return collection


if __name__ == "__main__":
					UpperCAmelCase_      							=     input("""Enter numbers separated by a comma:\n""").strip()
					UpperCAmelCase_      							=     [int(item) for item in user_input.split(""",""")]
					print(binary_insertion_sort(unsorted))



