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

import yaml





class       __A(				yaml.SafeLoader       ):

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



					def    lowercase__      (	self					:     Dict   ,					__UpperCamelCase					:     int   ,					__UpperCamelCase					:     Dict=False   ):
												lowerCamelCase_							  =					super().construct_mapping(__UpperCamelCase   ,					deep=__UpperCamelCase   )
												self._check_no_duplicates_on_constructed_node(__UpperCamelCase   )
												return mapping



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

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





class       __A(				UpperCAmelCase       ):
					# class attributes
					SCREAMING_SNAKE_CASE			    =    {'''train_eval_index'''}  # train-eval-index in the YAML metadata

					@classmethod
					def    lowercase__      (	cls					:     List[Any]   ,					__UpperCamelCase					:     Path   ):
												with open(__UpperCamelCase   ,					encoding="""utf-8"""   ) as readme_file:
																			lowerCamelCase_  ,   lowerCamelCase_							  =					_split_yaml_from_readme(readme_file.read()   )
												if yaml_string is not None:
																			return cls.from_yaml_string(__UpperCamelCase   )
												else:
																			return cls()

					def    lowercase__      (	self					:     Optional[Any]   ,					__UpperCamelCase					:     Path   ):
												if path.exists():
																			with open(__UpperCamelCase   ,					encoding="""utf-8"""   ) as readme_file:
																										lowerCamelCase_							  =					readme_file.read()
												else:
																			lowerCamelCase_							  =					None
												lowerCamelCase_							  =					self._to_readme(__UpperCamelCase   )
												with open(__UpperCamelCase   ,					"""w"""   ,					encoding="""utf-8"""   ) as readme_file:
																			readme_file.write(__UpperCamelCase   )

					def    lowercase__      (	self					:     str   ,					__UpperCamelCase					:     Optional[str] = None   ):
												if readme_content is not None:
																			lowerCamelCase_  ,   lowerCamelCase_							  =					_split_yaml_from_readme(__UpperCamelCase   )
																			lowerCamelCase_							  =					"""---\n""" + self.to_yaml_string() + """---\n""" + content
												else:
																			lowerCamelCase_							  =					"""---\n""" + self.to_yaml_string() + """---\n"""
												return full_content

					@classmethod
					def    lowercase__      (	cls					:     List[Any]   ,					__UpperCamelCase					:     str   ):
												lowerCamelCase_							  =					yaml.load(__UpperCamelCase   ,					Loader=_NoDuplicateSafeLoader   ) or {}

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



					def    lowercase__      (	self					:     Optional[Any]   ):
												return yaml.safe_dump(
												    {
												        (key.replace("""_"""   ,					"""-"""   ) if key in self._FIELDS_WITH_DASHES else key): value
												        for key, value in self.items()
												    }   ,					sort_keys=__UpperCamelCase   ,					allow_unicode=__UpperCamelCase   ,					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)







import os
import socket
from contextlib import contextmanager

import torch

from ..commands.config.default import write_basic_config  # noqa: F401
from ..state import PartialState
from .dataclasses import DistributedType
from .imports import is_deepspeed_available, is_tpu_available
from .transformer_engine import convert_model
from .versions import is_torch_version


if is_deepspeed_available():
		from deepspeed import DeepSpeedEngine

if is_tpu_available(check_device=False):
		import torch_xla.core.xla_model as xm



def      __lowerCAmelCase						(							UpperCAmelCase__				:      Any       )  ->    List[str]:
							if is_torch_version("""<"""			,				"""2.0.0"""       ) or not hasattr(UpperCAmelCase__			,				"""_dynamo"""       ):
														return False
							return isinstance(UpperCAmelCase__			,				torch._dynamo.eval_frame.OptimizedModule       )



def      __lowerCAmelCase						(							UpperCAmelCase__				:      str			,				UpperCAmelCase__				:      bool = True       )  ->    str:
							lowerCamelCase_							  =					(torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel)

							lowerCamelCase_							  =					is_compiled_module(UpperCAmelCase__       )
							if is_compiled:
														lowerCamelCase_							  =					model
														lowerCamelCase_							  =					model._orig_mod

							if is_deepspeed_available():
														options += (DeepSpeedEngine,)

							while isinstance(UpperCAmelCase__			,				UpperCAmelCase__       ):
														lowerCamelCase_							  =					model.module

							if not keep_fpaa_wrapper:
														lowerCamelCase_							  =					getattr(UpperCAmelCase__			,				"""forward"""       )
														lowerCamelCase_							  =					model.__dict__.pop("""_original_forward"""			,				UpperCAmelCase__       )
														if original_forward is not None:
																					while hasattr(UpperCAmelCase__			,				"""__wrapped__"""       ):
																												lowerCamelCase_							  =					forward.__wrapped__
																												if forward == original_forward:
																																			break
																					lowerCamelCase_							  =					forward
														if getattr(UpperCAmelCase__			,				"""_converted_to_transformer_engine"""			,				UpperCAmelCase__       ):
																					convert_model(UpperCAmelCase__			,				to_transformer_engine=UpperCAmelCase__       )

							if is_compiled:
														lowerCamelCase_							  =					model
														lowerCamelCase_							  =					compiled_model

							return model



def      __lowerCAmelCase						(							)  ->    Any:
							PartialState().wait_for_everyone()



def      __lowerCAmelCase						(							UpperCAmelCase__				:      Union[str, Any]			,				UpperCAmelCase__				:      Tuple       )  ->    Dict:
							if PartialState().distributed_type == DistributedType.TPU:
														xm.save(UpperCAmelCase__			,				UpperCAmelCase__       )
							elif PartialState().local_process_index == 0:
														torch.save(UpperCAmelCase__			,				UpperCAmelCase__       )



@contextmanager
def      __lowerCAmelCase						(							**UpperCAmelCase__				:      Any       )  ->    Dict:
							for key, value in kwargs.items():
														lowerCamelCase_							  =					str(UpperCAmelCase__       )

							yield

							for key in kwargs:
														if key.upper() in os.environ:
																					del os.environ[key.upper()]



def      __lowerCAmelCase						(							UpperCAmelCase__				:      Union[str, Any]       )  ->    str:
							if not hasattr(UpperCAmelCase__			,				"""__qualname__"""       ) and not hasattr(UpperCAmelCase__			,				"""__name__"""       ):
														lowerCamelCase_							  =					getattr(UpperCAmelCase__			,				"""__class__"""			,				UpperCAmelCase__       )
							if hasattr(UpperCAmelCase__			,				"""__qualname__"""       ):
														return obj.__qualname__
							if hasattr(UpperCAmelCase__			,				"""__name__"""       ):
														return obj.__name__
							return str(UpperCAmelCase__       )



def      __lowerCAmelCase						(							UpperCAmelCase__				:      str			,				UpperCAmelCase__				:      Union[str, Any]       )  ->    Dict:
							for key, value in source.items():
														if isinstance(UpperCAmelCase__			,				UpperCAmelCase__       ):
																					lowerCamelCase_							  =					destination.setdefault(UpperCAmelCase__			,				{}       )
																					merge_dicts(UpperCAmelCase__			,				UpperCAmelCase__       )
														else:
																					lowerCamelCase_							  =					value

							return destination



def      __lowerCAmelCase						(							UpperCAmelCase__				:      int = None       )  ->    bool:
							if port is None:
														lowerCamelCase_							  =					2_9_5_0_0
							with socket.socket(socket.AF_INET			,				socket.SOCK_STREAM       ) as s:
														return s.connect_ex(("""localhost""", port)       ) == 0





