'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list




class       __UpperCAmelCase							(							unittest.TestCase	):





       '''simple docstring'''



       def    __A			( self					)						->	Optional[int]:
           A_      =  '''<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K \' X J Q Z'''.split(''' '''					)
           A_      =  dict(zip(_SCREAMING_SNAKE_CASE       ,	range(len(_SCREAMING_SNAKE_CASE					)					)					)					)

           A_      =  {
               '''pad_token''': '''<pad>''',
               '''unk_token''': '''<unk>''',
               '''bos_token''': '''<s>''',
               '''eos_token''': '''</s>''',
           }
           A_      =  {
               '''feature_size''': 1,
               '''padding_value''': 0.0,
               '''sampling_rate''': 1_6000,
               '''return_attention_mask''': False,
               '''do_normalize''': True,
           }

           A_      =  tempfile.mkdtemp()
           A_      =  os.path.join(self.tmpdirname       ,	VOCAB_FILES_NAMES['''vocab_file''']					)
           A_      =  os.path.join(self.tmpdirname       ,	_SCREAMING_SNAKE_CASE					)
           with open(self.vocab_file       ,	'''w'''       ,	encoding='''utf-8'''					) as fp:
               fp.write(json.dumps(_SCREAMING_SNAKE_CASE					) + '''\n'''					)

           with open(self.feature_extraction_file       ,	'''w'''       ,	encoding='''utf-8'''					) as fp:
               fp.write(json.dumps(_SCREAMING_SNAKE_CASE					) + '''\n'''					)

       def    __A			( self       ,	**_SCREAMING_SNAKE_CASE					)						->	Any:
           A_      =  self.add_kwargs_tokens_map.copy()
           kwargs.update(_SCREAMING_SNAKE_CASE					)
           return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname       ,	**_SCREAMING_SNAKE_CASE					)

       def    __A			( self       ,	**_SCREAMING_SNAKE_CASE					)						->	Optional[Any]:
           return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname       ,	**_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	List[str]:
           shutil.rmtree(self.tmpdirname					)

       def    __A			( self					)						->	List[Any]:
           A_      =  self.get_tokenizer()
           A_      =  self.get_feature_extractor()

           A_      =  WavaVecaProcessor(tokenizer=_SCREAMING_SNAKE_CASE       ,	feature_extractor=_SCREAMING_SNAKE_CASE					)

           processor.save_pretrained(self.tmpdirname					)
           A_      =  WavaVecaProcessor.from_pretrained(self.tmpdirname					)

           self.assertEqual(processor.tokenizer.get_vocab()       ,	tokenizer.get_vocab()					)
           self.assertIsInstance(processor.tokenizer       ,	_SCREAMING_SNAKE_CASE					)

           self.assertEqual(processor.feature_extractor.to_json_string()       ,	feature_extractor.to_json_string()					)
           self.assertIsInstance(processor.feature_extractor       ,	_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	List[str]:
           A_      =  WavaVecaProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()					)
           processor.save_pretrained(self.tmpdirname					)

           A_      =  self.get_tokenizer(bos_token='''(BOS)'''       ,	eos_token='''(EOS)'''					)
           A_      =  self.get_feature_extractor(do_normalize=_SCREAMING_SNAKE_CASE       ,	padding_value=1.0					)

           A_      =  WavaVecaProcessor.from_pretrained(
               self.tmpdirname       ,	bos_token='''(BOS)'''       ,	eos_token='''(EOS)'''       ,	do_normalize=_SCREAMING_SNAKE_CASE       ,	padding_value=1.0					)

           self.assertEqual(processor.tokenizer.get_vocab()       ,	tokenizer_add_kwargs.get_vocab()					)
           self.assertIsInstance(processor.tokenizer       ,	_SCREAMING_SNAKE_CASE					)

           self.assertEqual(processor.feature_extractor.to_json_string()       ,	feature_extractor_add_kwargs.to_json_string()					)
           self.assertIsInstance(processor.feature_extractor       ,	_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Dict:
           A_      =  self.get_feature_extractor()
           A_      =  self.get_tokenizer()

           A_      =  WavaVecaProcessor(tokenizer=_SCREAMING_SNAKE_CASE       ,	feature_extractor=_SCREAMING_SNAKE_CASE					)

           A_      =  floats_list((3, 1000)					)

           A_      =  feature_extractor(_SCREAMING_SNAKE_CASE       ,	return_tensors='''np'''					)
           A_      =  processor(_SCREAMING_SNAKE_CASE       ,	return_tensors='''np'''					)

           for key in input_feat_extract.keys():
               self.assertAlmostEqual(input_feat_extract[key].sum()       ,	input_processor[key].sum()       ,	delta=1E-2					)

       def    __A			( self					)						->	Union[str, Any]:
           A_      =  self.get_feature_extractor()
           A_      =  self.get_tokenizer()

           A_      =  WavaVecaProcessor(tokenizer=_SCREAMING_SNAKE_CASE       ,	feature_extractor=_SCREAMING_SNAKE_CASE					)

           A_      =  '''This is a test string'''

           A_      =  processor(text=_SCREAMING_SNAKE_CASE					)

           A_      =  tokenizer(_SCREAMING_SNAKE_CASE					)

           for key in encoded_tok.keys():
               self.assertListEqual(encoded_tok[key]       ,	encoded_processor[key]					)

       def    __A			( self					)						->	List[str]:
           A_      =  self.get_feature_extractor()
           A_      =  self.get_tokenizer()

           A_      =  WavaVecaProcessor(tokenizer=_SCREAMING_SNAKE_CASE       ,	feature_extractor=_SCREAMING_SNAKE_CASE					)

           A_      =  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

           A_      =  processor.batch_decode(_SCREAMING_SNAKE_CASE					)
           A_      =  tokenizer.batch_decode(_SCREAMING_SNAKE_CASE					)

           self.assertListEqual(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Tuple:
           A_      =  self.get_feature_extractor()
           A_      =  self.get_tokenizer()

           A_      =  WavaVecaProcessor(tokenizer=_SCREAMING_SNAKE_CASE       ,	feature_extractor=_SCREAMING_SNAKE_CASE					)

           self.assertListEqual(
               processor.model_input_names       ,	feature_extractor.model_input_names       ,	msg='''`processor` and `feature_extractor` model input names do not match'''       ,	)







'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
  import tensorflow as tf

  from transformers.models.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )




class       __UpperCAmelCase							:





       '''simple docstring'''



       def __init__( self       ,	_SCREAMING_SNAKE_CASE       ,	)						->	Any:
           A_      =  parent
           A_      =  13
           A_      =  7
           A_      =  True
           A_      =  True
           A_      =  True
           A_      =  True
           A_      =  True
           A_      =  99
           A_      =  32
           A_      =  2
           A_      =  4
           A_      =  37
           A_      =  '''gelu'''
           A_      =  0.1
           A_      =  0.1
           A_      =  512
           A_      =  16
           A_      =  2
           A_      =  0.02
           A_      =  3
           A_      =  4
           A_      =  None
           A_      =  self.vocab_size - 1

       def    __A			( self					)						->	Union[str, Any]:
           A_      =  ids_tensor([self.batch_size, self.seq_length]       ,	self.vocab_size					)

           A_      =  None
           if self.use_input_mask:
               A_      =  random_attention_mask([self.batch_size, self.seq_length]					)

           A_      =  None
           if self.use_token_type_ids:
               A_      =  ids_tensor([self.batch_size, self.seq_length]       ,	self.type_vocab_size					)

           A_      =  None
           if self.use_mc_token_ids:
               A_      =  ids_tensor([self.batch_size, self.num_choices]       ,	self.seq_length					)

           A_      =  None
           A_      =  None
           A_      =  None
           if self.use_labels:
               A_      =  ids_tensor([self.batch_size]       ,	self.type_sequence_label_size					)
               A_      =  ids_tensor([self.batch_size, self.seq_length]       ,	self.num_labels					)
               A_      =  ids_tensor([self.batch_size]       ,	self.num_choices					)

           A_      =  OpenAIGPTConfig(
               vocab_size=self.vocab_size       ,	n_embd=self.hidden_size       ,	n_layer=self.num_hidden_layers       ,	n_head=self.num_attention_heads       ,	n_positions=self.max_position_embeddings       ,	pad_token_id=self.pad_token_id       ,	)

           A_      =  ids_tensor([self.num_hidden_layers, self.num_attention_heads]       ,	2					)

           return (
               config,
               input_ids,
               input_mask,
               head_mask,
               token_type_ids,
               mc_token_ids,
               sequence_labels,
               token_labels,
               choice_labels,
           )

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Optional[int]:
           A_      =  TFOpenAIGPTModel(config=_SCREAMING_SNAKE_CASE					)
           A_      =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           A_      =  model(_SCREAMING_SNAKE_CASE					)

           A_      =  [input_ids, input_mask]
           A_      =  model(_SCREAMING_SNAKE_CASE					)

           A_      =  model(_SCREAMING_SNAKE_CASE					)

           self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, self.seq_length, self.hidden_size)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  TFOpenAIGPTLMHeadModel(config=_SCREAMING_SNAKE_CASE					)
           A_      =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.vocab_size)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Optional[Any]:
           A_      =  TFOpenAIGPTDoubleHeadsModel(config=_SCREAMING_SNAKE_CASE					)

           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)
           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)
           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)

           A_      =  {
               '''input_ids''': multiple_choice_inputs_ids,
               '''mc_token_ids''': mc_token_ids,
               '''attention_mask''': multiple_choice_input_mask,
               '''token_type_ids''': multiple_choice_token_type_ids,
           }
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(
               result.logits.shape       ,	(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)					)
           self.parent.assertEqual(result.mc_logits.shape       ,	(self.batch_size, self.num_choices)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  self.num_labels
           A_      =  ids_tensor([self.batch_size]       ,	self.type_sequence_label_size					)
           A_      =  {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
               '''labels''': sequence_labels,
           }
           A_      =  TFOpenAIGPTForSequenceClassification(_SCREAMING_SNAKE_CASE					)
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)					)

       def    __A			( self					)						->	Union[str, Any]:
           A_      =  self.prepare_config_and_inputs()

           (
               (
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,
           )      =  config_and_inputs

           A_      =  {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
           return config, inputs_dict




@require_tf
class       __UpperCAmelCase							(							_UpperCamelCase		, _UpperCamelCase		, unittest.TestCase	):





       '''simple docstring'''



       __lowercase   :   Dict  					=							(
           (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
           if is_tf_available()
           else ()
       )
       __lowercase   :   List[str]  					=							(
           (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
       __lowercase   :   List[str]  					=							(
           {
               'feature-extraction': TFOpenAIGPTModel,
               'text-classification': TFOpenAIGPTForSequenceClassification,
               'text-generation': TFOpenAIGPTLMHeadModel,
               'zero-shot': TFOpenAIGPTForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowercase   :   Dict  					=							False
       __lowercase   :   Optional[int]  					=							False

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					)						->	Union[str, Any]:
           if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
               # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
               # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
               # tiny config could not be created.
               return True

           return False

       def    __A			( self					)						->	Any:
           A_      =  TFOpenAIGPTModelTester(self					)
           A_      =  ConfigTester(self       ,	config_class=_SCREAMING_SNAKE_CASE       ,	n_embd=37					)

       def    __A			( self					)						->	List[Any]:
           self.config_tester.run_common_tests()

       def    __A			( self					)						->	Dict:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_model(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Any:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_lm_head(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Tuple:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_double_head(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	List[str]:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_SCREAMING_SNAKE_CASE					)

       @slow
       def    __A			( self					)						->	Union[str, Any]:
           for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               A_      =  TFOpenAIGPTModel.from_pretrained(_SCREAMING_SNAKE_CASE					)
               self.assertIsNotNone(_SCREAMING_SNAKE_CASE					)




@require_tf
class       __UpperCAmelCase							(							unittest.TestCase	):





       '''simple docstring'''



       @slow
       def    __A			( self					)						->	List[str]:
           A_      =  TFOpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''					)
           A_      =  tf.convert_to_tensor([[481, 4735, 544]]       ,	dtype=tf.intaa					)  # the president is
           A_      =  [
               481,
               4735,
               544,
               246,
               963,
               870,
               762,
               239,
               244,
               4_0477,
               244,
               249,
               719,
               881,
               487,
               544,
               240,
               244,
               603,
               481,
           ]  # the president is a very good man. " \n " i\'m sure he is, " said the

           A_      =  model.generate(_SCREAMING_SNAKE_CASE       ,	do_sample=_SCREAMING_SNAKE_CASE					)
           self.assertListEqual(output_ids[0].numpy().tolist()       ,	_SCREAMING_SNAKE_CASE					)






