
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    _snake_case :
 __lowerCAmelCase	:  str	   =      BlenderbotConfig
 __lowerCAmelCase	:  Optional[Any]	   =      {}
 __lowerCAmelCase	:  str	   =      '''gelu'''


 def __init__(       self       ,	SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_=13       ,	SCREAMING_SNAKE_CASE_=7       ,	SCREAMING_SNAKE_CASE_=True       ,	SCREAMING_SNAKE_CASE_=False       ,	SCREAMING_SNAKE_CASE_=99       ,	SCREAMING_SNAKE_CASE_=32       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=4       ,	SCREAMING_SNAKE_CASE_=37       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=20       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=1       ,	SCREAMING_SNAKE_CASE_=0       ,	):


   '''simple docstring'''




   lowercase__	: Optional[Any]     		=   parent
   lowercase__	: List[Any]     		=   batch_size
   lowercase__	: Tuple     		=   seq_length
   lowercase__	: Optional[Any]     		=   is_training
   lowercase__	: Union[str, Any]     		=   use_labels
   lowercase__	: Tuple     		=   vocab_size
   lowercase__	: List[str]     		=   hidden_size
   lowercase__	: Any     		=   num_hidden_layers
   lowercase__	: Dict     		=   num_attention_heads
   lowercase__	: List[Any]     		=   intermediate_size

   lowercase__	: List[str]     		=   hidden_dropout_prob
   lowercase__	: Union[str, Any]     		=   attention_probs_dropout_prob
   lowercase__	: Optional[Any]     		=   max_position_embeddings
   lowercase__	: Any     		=   eos_token_id
   lowercase__	: Any     		=   pad_token_id
   lowercase__	: Dict     		=   bos_token_id


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Optional[int]     		=   ids_tensor([self.batch_size, self.seq_length - 1]       ,	self.vocab_size)
   lowercase__	: str     		=   tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size)       ,	1)
   lowercase__	: Union[str, Any]     		=   tf.concat([input_ids, eos_tensor]       ,	axis=1)

   lowercase__	: Tuple     		=   ids_tensor([self.batch_size, self.seq_length]       ,	self.vocab_size)

   lowercase__	: int     		=   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       ,	)
   lowercase__	: str     		=   prepare_blenderbot_inputs_dict(__lowerCamelCase       ,	__lowerCamelCase       ,	__lowerCamelCase)
   return config, inputs_dict



 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   lowercase__	: Optional[Any]     		=   TFBlenderbotModel(config=__lowerCamelCase).get_decoder()
   lowercase__	: int     		=   inputs_dict["""input_ids"""]

   lowercase__	: Optional[Any]     		=   input_ids[:1, :]
   lowercase__	: Any     		=   inputs_dict["""attention_mask"""][:1, :]
   lowercase__	: List[str]     		=   inputs_dict["""head_mask"""]
   lowercase__	: Optional[int]     		=   1

   # first forward pass
   lowercase__	: Tuple     		=   model(__lowerCamelCase       ,	attention_mask=__lowerCamelCase       ,	head_mask=__lowerCamelCase       ,	use_cache=__lowerCamelCase)

   lowercase__		,     lowercase__	: List[Any]     		=   outputs.to_tuple()

   # create hypothetical next token and extent to next_input_ids
   lowercase__	: Any     		=   ids_tensor((self.batch_size, 3)       ,	config.vocab_size)
   lowercase__	: List[str]     		=   tf.cast(ids_tensor((self.batch_size, 3)       ,	2)       ,	tf.inta)

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

   lowercase__	: Union[str, Any]     		=   model(__lowerCamelCase       ,	attention_mask=__lowerCamelCase)[0]
   lowercase__	: List[Any]     		=   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
   lowercase__	: List[str]     		=   int(ids_tensor((1,)       ,	output_from_past.shape[-1]))
   lowercase__	: str     		=   output_from_no_past[:, -3:, random_slice_idx]
   lowercase__	: Any     		=   output_from_past[:, :, random_slice_idx]

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

def 		UpperCamelCase						(   lowercase_			,			lowercase_			,			lowercase_			,			lowercase_=None			,			lowercase_=None			,			lowercase_=None			,			lowercase_=None			,			lowercase_=None			,			)		->						Union[str, Any]:


  '''simple docstring'''






  if attention_mask is None:
    lowercase__	: List[str]     		=   tf.cast(tf.math.not_equal(lowerCAmelCase_			,			config.pad_token_id )			,			tf.inta )
  if decoder_attention_mask is None:
    lowercase__	: Any     		=   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:
    lowercase__	: Any     		=   tf.ones((config.encoder_layers, config.encoder_attention_heads) )
  if decoder_head_mask is None:
    lowercase__	: Union[str, Any]     		=   tf.ones((config.decoder_layers, config.decoder_attention_heads) )
  if cross_attn_head_mask is None:
    lowercase__	: List[str]     		=   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    _snake_case (						__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    unittest.TestCase				):
 __lowerCAmelCase	:  Dict	   =      (TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
 __lowerCAmelCase	:  Optional[Any]	   =      (TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
 __lowerCAmelCase	:  Dict	   =      (
     {
         '''conversational''': TFBlenderbotForConditionalGeneration,
         '''feature-extraction''': TFBlenderbotModel,
         '''summarization''': TFBlenderbotForConditionalGeneration,
         '''text2text-generation''': TFBlenderbotForConditionalGeneration,
         '''translation''': TFBlenderbotForConditionalGeneration,
     }
     if is_tf_available()
     else {}
 )
 __lowerCAmelCase	:  str	   =      True
 __lowerCAmelCase	:  List[Any]	   =      False
 __lowerCAmelCase	:  Union[str, Any]	   =      False


 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: Optional[int]     		=   TFBlenderbotModelTester(self)
   lowercase__	: Tuple     		=   ConfigTester(self       ,	config_class=__lowerCamelCase)


 def   lowercase__  (       self):


   '''simple docstring'''




   self.config_tester.run_common_tests()



 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: int     		=   self.model_tester.prepare_config_and_inputs_for_common()
   self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase)



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


 @cached_property
 def   lowercase__  (       self):


   '''simple docstring'''




   return BlenderbotTokenizer.from_pretrained(self.model_name)


 @cached_property
 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: List[str]     		=   TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name)
   return model



 @slow
 def   lowercase__  (       self):


   '''simple docstring'''




   lowercase__	: List[str]     		=   self.tokenizer(self.src_text       ,	return_tensors="""tf""")
   lowercase__	: int     		=   self.model.generate(
       model_inputs.input_ids       ,	)
   lowercase__	: List[str]     		=   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)





