
"""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							:




      def __init__(							self      ,				lowercase_      ,				)  ->    Optional[int]:
          UpperCAmelCase  	=    parent
          UpperCAmelCase  	=    1_3
          UpperCAmelCase  	=    7
          UpperCAmelCase  	=    True
          UpperCAmelCase  	=    True
          UpperCAmelCase  	=    True
          UpperCAmelCase  	=    True
          UpperCAmelCase  	=    True
          UpperCAmelCase  	=    9_9
          UpperCAmelCase  	=    3_2
          UpperCAmelCase  	=    2
          UpperCAmelCase  	=    4
          UpperCAmelCase  	=    3_7
          UpperCAmelCase  	=    'gelu'
          UpperCAmelCase  	=    0.1
          UpperCAmelCase  	=    0.1
          UpperCAmelCase  	=    5_1_2
          UpperCAmelCase  	=    1_6
          UpperCAmelCase  	=    2
          UpperCAmelCase  	=    0.0_2
          UpperCAmelCase  	=    3
          UpperCAmelCase  	=    4
          UpperCAmelCase  	=    None
          UpperCAmelCase  	=    self.vocab_size - 1




      def 			a_					(							self							)  ->    int:
          UpperCAmelCase  	=    ids_tensor([self.batch_size, self.seq_length]      ,				self.vocab_size							)

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

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

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

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

          UpperCAmelCase  	=    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      ,				)

          UpperCAmelCase  	=    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      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				*lowercase_							)  ->    str:
          UpperCAmelCase  	=    TFOpenAIGPTModel(config=lowercase_							)
          UpperCAmelCase  	=    {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          UpperCAmelCase  	=    model(lowercase_							)

          UpperCAmelCase  	=    [input_ids, input_mask]
          UpperCAmelCase  	=    model(lowercase_							)

          UpperCAmelCase  	=    model(lowercase_							)

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




      def 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				*lowercase_							)  ->    Optional[Any]:
          UpperCAmelCase  	=    TFOpenAIGPTLMHeadModel(config=lowercase_							)
          UpperCAmelCase  	=    {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
          UpperCAmelCase  	=    model(lowercase_							)
          self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.seq_length, self.vocab_size)							)




      def 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				*lowercase_							)  ->    Tuple:
          UpperCAmelCase  	=    TFOpenAIGPTDoubleHeadsModel(config=lowercase_							)

          UpperCAmelCase  	=    tf.tile(tf.expand_dims(lowercase_      ,				1							)      ,				(1, self.num_choices, 1)							)
          UpperCAmelCase  	=    tf.tile(tf.expand_dims(lowercase_      ,				1							)      ,				(1, self.num_choices, 1)							)
          UpperCAmelCase  	=    tf.tile(tf.expand_dims(lowercase_      ,				1							)      ,				(1, self.num_choices, 1)							)

          UpperCAmelCase  	=    {
              '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,
          }
          UpperCAmelCase  	=    model(lowercase_							)
          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      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				*lowercase_							)  ->    Any:
          UpperCAmelCase  	=    self.num_labels
          UpperCAmelCase  	=    ids_tensor([self.batch_size]      ,				self.type_sequence_label_size							)
          UpperCAmelCase  	=    {
              'input_ids': input_ids,
              'attention_mask': input_mask,
              'token_type_ids': token_type_ids,
              'labels': sequence_labels,
          }
          UpperCAmelCase  	=    TFOpenAIGPTForSequenceClassification(lowercase_							)
          UpperCAmelCase  	=    model(lowercase_							)
          self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels)							)




      def 			a_					(							self							)  ->    Tuple:
          UpperCAmelCase  	=    self.prepare_config_and_inputs()

          (
              (
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							(
              UpperCAmelCase
          )	,							
          )  	=    config_and_inputs

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

@require_tf
class    _UpperCAmelCase							(						SCREAMING_SNAKE_CASE_   ,	SCREAMING_SNAKE_CASE_   ,	unittest.TestCase							):
      __SCREAMING_SNAKE_CASE      :							str												=		(
          (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
          if is_tf_available()
          else ()
      )
      __SCREAMING_SNAKE_CASE      :							Any												=		(
          (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
      __SCREAMING_SNAKE_CASE      :							Any												=		(
          {
              "feature-extraction": TFOpenAIGPTModel,
              "text-classification": TFOpenAIGPTForSequenceClassification,
              "text-generation": TFOpenAIGPTLMHeadModel,
              "zero-shot": TFOpenAIGPTForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      __SCREAMING_SNAKE_CASE      :							List[str]												=		False
      __SCREAMING_SNAKE_CASE      :							List[Any]												=		False




      def 			a_					(							self      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_      ,				lowercase_							)  ->    Tuple:
          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							)  ->    Dict:
          UpperCAmelCase  	=    TFOpenAIGPTModelTester(self							)
          UpperCAmelCase  	=    ConfigTester(self      ,				config_class=lowercase_      ,				n_embd=3_7							)




      def 			a_					(							self							)  ->    List[str]:
          self.config_tester.run_common_tests()




      def 			a_					(							self							)  ->    Optional[int]:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_openai_gpt_model(*lowercase_							)




      def 			a_					(							self							)  ->    List[str]:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_openai_gpt_lm_head(*lowercase_							)




      def 			a_					(							self							)  ->    Tuple:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_openai_gpt_double_head(*lowercase_							)




      def 			a_					(							self							)  ->    Any:
          UpperCAmelCase  	=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowercase_							)




      @slow
      def 			a_					(							self							)  ->    Tuple:
          for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase  	=    TFOpenAIGPTModel.from_pretrained(lowercase_							)
              self.assertIsNotNone(lowercase_							)

@require_tf
class    _UpperCAmelCase							(						unittest.TestCase							):




      @slow
      def 			a_					(							self							)  ->    Any:
          UpperCAmelCase  	=    TFOpenAIGPTLMHeadModel.from_pretrained('openai-gpt'							)
          UpperCAmelCase  	=    tf.convert_to_tensor([[4_8_1, 4_7_3_5, 5_4_4]]      ,				dtype=tf.intaa							)  # the president is
          UpperCAmelCase  	=    [
              4_8_1,
              4_7_3_5,
              5_4_4,
              2_4_6,
              9_6_3,
              8_7_0,
              7_6_2,
              2_3_9,
              2_4_4,
              4_0_4_7_7,
              2_4_4,
              2_4_9,
              7_1_9,
              8_8_1,
              4_8_7,
              5_4_4,
              2_4_0,
              2_4_4,
              6_0_3,
              4_8_1,
          ]  # the president is a very good man. " \n " i\'m sure he is, " said the

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





"""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							):




      def 			a_					(							self							)  ->    Any:
          UpperCAmelCase  	=    '<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(' '							)
          UpperCAmelCase  	=    dict(zip(lowercase_      ,				range(len(lowercase_							)							)							)							)

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

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

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




      def 			a_					(							self      ,				**lowercase_							)  ->    Any:
          UpperCAmelCase  	=    self.add_kwargs_tokens_map.copy()
          kwargs.update(lowercase_							)
          return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname      ,				**lowercase_							)




      def 			a_					(							self      ,				**lowercase_							)  ->    Dict:
          return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname      ,				**lowercase_							)




      def 			a_					(							self							)  ->    Any:
          shutil.rmtree(self.tmpdirname							)




      def 			a_					(							self							)  ->    Tuple:
          UpperCAmelCase  	=    self.get_tokenizer()
          UpperCAmelCase  	=    self.get_feature_extractor()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

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

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

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




      def 			a_					(							self							)  ->    Dict:
          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=self.get_tokenizer()      ,				feature_extractor=self.get_feature_extractor()							)
          processor.save_pretrained(self.tmpdirname							)

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

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

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

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




      def 			a_					(							self							)  ->    Tuple:
          UpperCAmelCase  	=    self.get_feature_extractor()
          UpperCAmelCase  	=    self.get_tokenizer()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

          UpperCAmelCase  	=    floats_list((3, 1_0_0_0)							)

          UpperCAmelCase  	=    feature_extractor(lowercase_      ,				return_tensors='np'							)
          UpperCAmelCase  	=    processor(lowercase_      ,				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							)  ->    List[str]:
          UpperCAmelCase  	=    self.get_feature_extractor()
          UpperCAmelCase  	=    self.get_tokenizer()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

          UpperCAmelCase  	=    'This is a test string'

          UpperCAmelCase  	=    processor(text=lowercase_							)

          UpperCAmelCase  	=    tokenizer(lowercase_							)

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




      def 			a_					(							self							)  ->    List[str]:
          UpperCAmelCase  	=    self.get_feature_extractor()
          UpperCAmelCase  	=    self.get_tokenizer()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

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

          UpperCAmelCase  	=    processor.batch_decode(lowercase_							)
          UpperCAmelCase  	=    tokenizer.batch_decode(lowercase_							)

          self.assertListEqual(lowercase_      ,				lowercase_							)




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

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

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



