





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_snake_case :    Tuple           =			{
    """configuration_electra""": ["""ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ElectraConfig""", """ElectraOnnxConfig"""],
    """tokenization_electra""": ["""ElectraTokenizer"""],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case :    Dict           =			["""ElectraTokenizerFast"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case :    Tuple           =			[
      """ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """ElectraForCausalLM""",
      """ElectraForMaskedLM""",
      """ElectraForMultipleChoice""",
      """ElectraForPreTraining""",
      """ElectraForQuestionAnswering""",
      """ElectraForSequenceClassification""",
      """ElectraForTokenClassification""",
      """ElectraModel""",
      """ElectraPreTrainedModel""",
      """load_tf_weights_in_electra""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case :    Optional[int]           =			[
      """TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFElectraForMaskedLM""",
      """TFElectraForMultipleChoice""",
      """TFElectraForPreTraining""",
      """TFElectraForQuestionAnswering""",
      """TFElectraForSequenceClassification""",
      """TFElectraForTokenClassification""",
      """TFElectraModel""",
      """TFElectraPreTrainedModel""",
  ]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case :    List[Any]           =			[
      """FlaxElectraForCausalLM""",
      """FlaxElectraForMaskedLM""",
      """FlaxElectraForMultipleChoice""",
      """FlaxElectraForPreTraining""",
      """FlaxElectraForQuestionAnswering""",
      """FlaxElectraForSequenceClassification""",
      """FlaxElectraForTokenClassification""",
      """FlaxElectraModel""",
      """FlaxElectraPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
  from .tokenization_electra import ElectraTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_electra_fast import ElectraTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_electra import (
        ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
        ElectraForCausalLM,
        ElectraForMaskedLM,
        ElectraForMultipleChoice,
        ElectraForPreTraining,
        ElectraForQuestionAnswering,
        ElectraForSequenceClassification,
        ElectraForTokenClassification,
        ElectraModel,
        ElectraPreTrainedModel,
        load_tf_weights_in_electra,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_electra import (
        TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFElectraForMaskedLM,
        TFElectraForMultipleChoice,
        TFElectraForPreTraining,
        TFElectraForQuestionAnswering,
        TFElectraForSequenceClassification,
        TFElectraForTokenClassification,
        TFElectraModel,
        TFElectraPreTrainedModel,
    )

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_electra import (
        FlaxElectraForCausalLM,
        FlaxElectraForMaskedLM,
        FlaxElectraForMultipleChoice,
        FlaxElectraForPreTraining,
        FlaxElectraForQuestionAnswering,
        FlaxElectraForSequenceClassification,
        FlaxElectraForTokenClassification,
        FlaxElectraModel,
        FlaxElectraPreTrainedModel,
    )

else:
  import sys

  _snake_case :    str           =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)













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

import yaml





class  lowerCAmelCase							(       yaml.SafeLoader ):







  def   UpperCAmelCase					(      self  :Optional[Any]   ,							_lowercase  :Any ):






     '''simple docstring'''





     lowercase__			       =  [self.constructed_objects[key_node] for key_node, _ in node.value]
     lowercase__			       =  [tuple(_lowercase ) if isinstance(_lowercase   ,							_lowercase ) else key for key in keys]
     lowercase__			       =  Counter(_lowercase )
     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  :Any   ,							_lowercase  :str   ,							_lowercase  :Dict=False ):






     '''simple docstring'''





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


def _A       (   __magic_name__	):
   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(__magic_name__	)





class  lowerCAmelCase							(       lowercase_ ):
  # class attributes
  __lowerCamelCase		=      {'train_eval_index'}  # train-eval-index in the YAML metadata







  @classmethod
  def   UpperCAmelCase					(      cls  :Dict   ,							_lowercase  :Path ):






     '''simple docstring'''





     with open(_lowercase   ,							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(_lowercase )
     else:
        return cls()







  def   UpperCAmelCase					(      self  :Any   ,							_lowercase  :Path ):






     '''simple docstring'''





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







  def   UpperCAmelCase					(      self  :List[str]   ,							_lowercase  :Optional[str] = None ):






     '''simple docstring'''





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







  @classmethod
  def   UpperCAmelCase					(      cls  :Any   ,							_lowercase  :str ):






     '''simple docstring'''





     lowercase__			       =  yaml.load(_lowercase   ,							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(**_lowercase )







  def   UpperCAmelCase					(      self  :Union[str, Any] ):






     '''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=_lowercase   ,							allow_unicode=_lowercase   ,							encoding="utf-8"   ,							).decode("utf-8" )
_snake_case           =			{
    """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

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

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






