


'''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    :    Any   ,						UpperCamelCase    :    List[str] ):

             '''simple docstring'''







             lowercase__      			= [self.constructed_objects[key_node] for key_node, _ in node.value]
             lowercase__      			= [tuple(UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else key for key in keys]
             lowercase__      			= Counter(UpperCamelCase )
             lowercase__      			= [key for key in counter if counter[key] > 1]
             if duplicate_keys:
                    raise TypeError(f"Got duplicate yaml keys: {duplicate_keys}" )






      def       UpperCamelCase__		(self    :    Dict   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Optional[int]=False ):

             '''simple docstring'''







             lowercase__      			= super().construct_mapping(UpperCamelCase   ,						deep=UpperCamelCase )
             self._check_no_duplicates_on_constructed_node(UpperCamelCase )
             return mapping






def _SCREAMING_SNAKE_CASE      (A       )       ->       Tuple[Optional[str], str]:






       """simple docstring"""







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

       return None, "\n".join(A       )
class   __lowerCAmelCase						(lowercase_     ):





      '''simple docstring'''






      lowerCAmelCase__					:     Any  					=							{"""train_eval_index"""}  # train-eval-index in the YAML metadata



      @classmethod
      def       UpperCamelCase__		(cls    :    List[str]   ,						UpperCamelCase    :    Path ):

             '''simple docstring'''







             with open(UpperCamelCase   ,						encoding='''utf-8''' ) as readme_file:
                    lowercase__			,lowercase__      			= _split_yaml_from_readme(readme_file.read() )
             if yaml_string is not None:
                    return cls.from_yaml_string(UpperCamelCase )
             else:
                    return cls()



      def       UpperCamelCase__		(self    :    List[str]   ,						UpperCamelCase    :    Path ):

             '''simple docstring'''







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



      def       UpperCamelCase__		(self    :    Union[str, Any]   ,						UpperCamelCase    :    Optional[str] = None ):

             '''simple docstring'''







             if readme_content is not None:
                    lowercase__			,lowercase__      			= _split_yaml_from_readme(UpperCamelCase )
                    lowercase__      			= '''---\n''' + self.to_yaml_string() + '''---\n''' + content
             else:
                    lowercase__      			= '''---\n''' + self.to_yaml_string() + '''---\n'''
             return full_content



      @classmethod
      def       UpperCamelCase__		(cls    :    int   ,						UpperCamelCase    :    str ):

             '''simple docstring'''







             lowercase__      			= yaml.load(UpperCamelCase   ,						Loader=_NoDuplicateSafeLoader ) or {}

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






      def       UpperCamelCase__		(self    :    List[str] ):

             '''simple docstring'''







             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''' )






lowerCamelCase							:   List[str]  						=	{
    '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							:   Dict  						=	ArgumentParser(usage='Validate the yaml metadata block of a README.md file.')
 ap.add_argument('readme_filepath')
 lowerCamelCase							:   Optional[Any]  						=	ap.parse_args()

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








'''simple docstring'''

from ....utils import logging


lowerCamelCase							:   Optional[Any]  						=	logging.get_logger(__name__)
class   __lowerCAmelCase						(lowercase_     ):





      '''simple docstring'''






      def __init__(self    :    Optional[int]   ,						UpperCamelCase    :    Union[str, Any]   ,						UpperCamelCase    :    Optional[Any]=None   ,						UpperCamelCase    :    int=2048 ):

             '''simple docstring'''







             lowercase__      			= config.__dict__
             lowercase__      			= modal_hidden_size
             if num_labels:
                    lowercase__      			= num_labels




