



"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import BlenderbotConfig, BlenderbotTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotForConditionalGeneration, TFBlenderbotModel



@require_tf
class     UpperCAmelCase    :
   A__		:	str           =  BlenderbotConfig
   A__		:	Optional[Any]           =  {}
   A__		:	str           =  '''gelu'''



   def __init__(       self    :	Any							,       __lowerCamelCase    :	Dict							,       __lowerCamelCase    :	int=1_3							,       __lowerCamelCase    :	Union[str, Any]=7							,       __lowerCamelCase    :	Tuple=True							,       __lowerCamelCase    :	str=False							,       __lowerCamelCase    :	Dict=9_9							,       __lowerCamelCase    :	Optional[Any]=3_2							,       __lowerCamelCase    :	int=2							,       __lowerCamelCase    :	Optional[Any]=4							,       __lowerCamelCase    :	List[Any]=3_7							,       __lowerCamelCase    :	Any=0.1							,       __lowerCamelCase    :	Any=0.1							,       __lowerCamelCase    :	Union[str, Any]=2_0							,       __lowerCamelCase    :	Union[str, Any]=2							,       __lowerCamelCase    :	str=1							,       __lowerCamelCase    :	str=0							,       ):



     """simple docstring"""
     _snake_case   	=      parent
     _snake_case   	=      batch_size
     _snake_case   	=      seq_length
     _snake_case   	=      is_training
     _snake_case   	=      use_labels
     _snake_case   	=      vocab_size
     _snake_case   	=      hidden_size
     _snake_case   	=      num_hidden_layers
     _snake_case   	=      num_attention_heads
     _snake_case   	=      intermediate_size

     _snake_case   	=      hidden_dropout_prob
     _snake_case   	=      attention_probs_dropout_prob
     _snake_case   	=      max_position_embeddings
     _snake_case   	=      eos_token_id
     _snake_case   	=      pad_token_id
     _snake_case   	=      bos_token_id



   def    __UpperCAmelCase    (       self    :	Tuple				):



     """simple docstring"""
     _snake_case   	=      ids_tensor([self.batch_size, self.seq_length - 1]							,       self.vocab_size				)
     _snake_case   	=      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size				)							,       1				)
     _snake_case   	=      tf.concat([input_ids, eos_tensor]							,       axis=1				)

     _snake_case   	=      ids_tensor([self.batch_size, self.seq_length]							,       self.vocab_size				)

     _snake_case   	=      self.config_cls(
         vocab_size=self.vocab_size							,       d_model=self.hidden_size							,       encoder_layers=self.num_hidden_layers							,       decoder_layers=self.num_hidden_layers							,       encoder_attention_heads=self.num_attention_heads							,       decoder_attention_heads=self.num_attention_heads							,       encoder_ffn_dim=self.intermediate_size							,       decoder_ffn_dim=self.intermediate_size							,       dropout=self.hidden_dropout_prob							,       attention_dropout=self.attention_probs_dropout_prob							,       max_position_embeddings=self.max_position_embeddings							,       eos_token_ids=[2]							,       bos_token_id=self.bos_token_id							,       pad_token_id=self.pad_token_id							,       decoder_start_token_id=self.pad_token_id							,       **self.config_updates							,       )
     _snake_case   	=      prepare_blenderbot_inputs_dict(__lowerCamelCase							,       __lowerCamelCase							,       __lowerCamelCase				)
     return config, inputs_dict





   def    __UpperCAmelCase    (       self    :	Optional[int]							,       __lowerCamelCase    :	int							,       __lowerCamelCase    :	str				):



     """simple docstring"""
     _snake_case   	=      TFBlenderbotModel(config=__lowerCamelCase				).get_decoder()
     _snake_case   	=      inputs_dict['''input_ids''']

     _snake_case   	=      input_ids[:1, :]
     _snake_case   	=      inputs_dict['''attention_mask'''][:1, :]
     _snake_case   	=      inputs_dict['''head_mask''']
     _snake_case   	=      1

     # first forward pass
     _snake_case   	=      model(__lowerCamelCase							,       attention_mask=__lowerCamelCase							,       head_mask=__lowerCamelCase							,       use_cache=__lowerCamelCase				)

     _snake_case	,     _snake_case   	=      outputs.to_tuple()

     # create hypothetical next token and extent to next_input_ids
     _snake_case   	=      ids_tensor((self.batch_size, 3)							,       config.vocab_size				)
     _snake_case   	=      tf.cast(ids_tensor((self.batch_size, 3)							,       2				)							,       tf.inta				)

     # append to next input_ids and
     _snake_case   	=      tf.concat([input_ids, next_tokens]							,       axis=-1				)
     _snake_case   	=      tf.concat([attention_mask, next_attn_mask]							,       axis=-1				)

     _snake_case   	=      model(__lowerCamelCase							,       attention_mask=__lowerCamelCase				)[0]
     _snake_case   	=      model(__lowerCamelCase							,       attention_mask=__lowerCamelCase							,       past_key_values=__lowerCamelCase				)[0]

     self.parent.assertEqual(next_tokens.shape[1]							,       output_from_past.shape[1]				)

     # select random slice
     _snake_case   	=      int(ids_tensor((1,)							,       output_from_past.shape[-1]				)				)
     _snake_case   	=      output_from_no_past[:, -3:, random_slice_idx]
     _snake_case   	=      output_from_past[:, :, random_slice_idx]

     # test that outputs are equal for slice
     tf.debugging.assert_near(__lowerCamelCase							,       __lowerCamelCase							,       rtol=1E-3				)




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=None  ,						)						->				Union[str, Any]:
  if attention_mask is None:
    _snake_case   	=      tf.cast(tf.math.not_equal(lowerCAmelCase_  ,						config.pad_token_id	)  ,						tf.inta	)
  if decoder_attention_mask is None:
    _snake_case   	=      tf.concat(
        [
            tf.ones(decoder_input_ids[:, :1].shape  ,						dtype=tf.inta	),
            tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]  ,						config.pad_token_id	)  ,						tf.inta	),
        ]  ,						axis=-1  ,						)
  if head_mask is None:
    _snake_case   	=      tf.ones((config.encoder_layers, config.encoder_attention_heads)	)
  if decoder_head_mask is None:
    _snake_case   	=      tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
  if cross_attn_head_mask is None:
    _snake_case   	=      tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
  return {
      "input_ids": input_ids,
      "decoder_input_ids": decoder_input_ids,
      "attention_mask": attention_mask,
      "decoder_attention_mask": decoder_attention_mask,
      "head_mask": head_mask,
      "decoder_head_mask": decoder_head_mask,
      "cross_attn_head_mask": cross_attn_head_mask,
  }



@require_tf
class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,unittest.TestCase  ):
   A__		:	Dict           =  (TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
   A__		:	Optional[Any]           =  (TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
   A__		:	Dict           =  (
       {
           '''conversational''': TFBlenderbotForConditionalGeneration,
           '''feature-extraction''': TFBlenderbotModel,
           '''summarization''': TFBlenderbotForConditionalGeneration,
           '''text2text-generation''': TFBlenderbotForConditionalGeneration,
           '''translation''': TFBlenderbotForConditionalGeneration,
       }
       if is_tf_available()
       else {}
   )
   A__		:	str           =  True
   A__		:	List[Any]           =  False
   A__		:	Union[str, Any]           =  False



   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case   	=      TFBlenderbotModelTester(self				)
     _snake_case   	=      ConfigTester(self							,       config_class=__lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Optional[int]				):



     """simple docstring"""
     self.config_tester.run_common_tests()





   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     _snake_case   	=      self.model_tester.prepare_config_and_inputs_for_common()
     self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase				)



@require_tokenizers
@require_tf
class     UpperCAmelCase    (	unittest.TestCase  ):
   A__		:	List[str]           =  ['''My friends are cool but they eat too many carbs.''']
   A__		:	str           =  '''facebook/blenderbot-400M-distill'''



   @cached_property
   def    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     return BlenderbotTokenizer.from_pretrained(self.model_name				)



   @cached_property
   def    __UpperCAmelCase    (       self    :	Any				):



     """simple docstring"""
     _snake_case   	=      TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name				)
     return model





   @slow
   def    __UpperCAmelCase    (       self    :	List[str]				):



     """simple docstring"""
     _snake_case   	=      self.tokenizer(self.src_text							,       return_tensors='''tf'''				)
     _snake_case   	=      self.model.generate(
         model_inputs.input_ids							,       )
     _snake_case   	=      self.tokenizer.batch_decode(generated_ids.numpy()							,       skip_special_tokens=__lowerCamelCase				)[0]
     assert (
         generated_words
         == " That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?"
     )










"""simple docstring"""






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

import yaml



class     UpperCAmelCase    (	yaml.SafeLoader  ):



   def    __UpperCAmelCase    (       self    :	Tuple							,       __lowerCamelCase    :	List[str]				):



     """simple docstring"""
     _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    __UpperCAmelCase    (       self    :	str							,       __lowerCamelCase    :	Any							,       __lowerCamelCase    :	Optional[Any]=False				):



     """simple docstring"""
     _snake_case   	=      super().construct_mapping(__lowerCamelCase							,       deep=__lowerCamelCase				)
     self._check_no_duplicates_on_constructed_node(__lowerCamelCase				)
     return mapping




def 			snake_case		(		lowerCAmelCase_	)						->				Tuple[Optional[str], str]:
  _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(lowerCAmelCase_	)



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



   @classmethod
   def    __UpperCAmelCase    (       cls    :	str							,       __lowerCamelCase    :	Path				):



     """simple docstring"""
     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    __UpperCAmelCase    (       self    :	List[Any]							,       __lowerCamelCase    :	Path				):



     """simple docstring"""
     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    __UpperCAmelCase    (       self    :	Union[str, Any]							,       __lowerCamelCase    :	Optional[str] = None				):



     """simple docstring"""
     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    __UpperCAmelCase    (       cls    :	Tuple							,       __lowerCamelCase    :	str				):



     """simple docstring"""
     _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    __UpperCAmelCase    (       self    :	Dict				):



     """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=__lowerCamelCase							,       allow_unicode=__lowerCamelCase							,       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)





