




from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
						import tensorflow as tf

						from transformers.models.xglm.modeling_tf_xglm import (
						    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFXGLMForCausalLM,
						    TFXGLMModel,
						)







@require_tf
class 				lowerCAmelCase_       :
				__a     :       List[Any]						=     XGLMConfig
				__a     :       List[Any]						=     {}
				__a     :       List[str]						=     "gelu"






				def __init__(			self      ,snake_case__      ,snake_case__=14      ,snake_case__=7      ,snake_case__=True      ,snake_case__=True      ,snake_case__=True      ,snake_case__=99      ,snake_case__=32      ,snake_case__=2      ,snake_case__=4      ,snake_case__=37      ,snake_case__="gelu"      ,snake_case__=0.1      ,snake_case__=0.1      ,snake_case__=512      ,snake_case__=0.02      ,):
							SCREAMING_SNAKE_CASE_   : int					  =      parent
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      batch_size
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      seq_length
							SCREAMING_SNAKE_CASE_   : List[str]					  =      is_training
							SCREAMING_SNAKE_CASE_   : int					  =      use_input_mask
							SCREAMING_SNAKE_CASE_   : Tuple					  =      use_labels
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      vocab_size
							SCREAMING_SNAKE_CASE_   : int					  =      d_model
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      num_hidden_layers
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      num_attention_heads
							SCREAMING_SNAKE_CASE_   : List[str]					  =      ffn_dim
							SCREAMING_SNAKE_CASE_   : Any					  =      activation_function
							SCREAMING_SNAKE_CASE_   : Dict					  =      activation_dropout
							SCREAMING_SNAKE_CASE_   : int					  =      attention_dropout
							SCREAMING_SNAKE_CASE_   : str					  =      max_position_embeddings
							SCREAMING_SNAKE_CASE_   : Any					  =      initializer_range
							SCREAMING_SNAKE_CASE_   : int					  =      None
							SCREAMING_SNAKE_CASE_   : str					  =      0
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      2
							SCREAMING_SNAKE_CASE_   : Any					  =      1






				def 		snake_case	(			self ):
							return XGLMConfig.from_pretrained('facebook/xglm-564M' )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf.clip_by_value(
							    ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size )      ,clip_value_min=0      ,clip_value_max=3 )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      None
							if self.use_input_mask:
										SCREAMING_SNAKE_CASE_   : List[str]					  =      random_attention_mask([self.batch_size, self.seq_length] )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.get_config()

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      floats_tensor([self.num_hidden_layers, self.num_attention_heads]      ,2 )

							return (
							    config,
							    input_ids,
							    input_mask,
							    head_mask,
							)






				def 		snake_case	(			self ):
							return XGLMConfig(
							    vocab_size=self.vocab_size      ,d_model=self.hidden_size      ,num_layers=self.num_hidden_layers      ,attention_heads=self.num_attention_heads      ,ffn_dim=self.ffn_dim      ,activation_function=self.activation_function      ,activation_dropout=self.activation_dropout      ,attention_dropout=self.attention_dropout      ,max_position_embeddings=self.max_position_embeddings      ,initializer_range=self.initializer_range      ,use_cache=snake_case__      ,bos_token_id=self.bos_token_id      ,eos_token_id=self.eos_token_id      ,pad_token_id=self.pad_token_id      ,return_dict=snake_case__      ,)






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      self.prepare_config_and_inputs()

							(
							    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    
							)   : List[Any]					  =      config_and_inputs

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      {
							    'input_ids': input_ids,
							    'head_mask': head_mask,
							}

							return config, inputs_dict







@require_tf
class 				lowerCAmelCase_       (					lowerCamelCase_						,     lowerCamelCase_						,     unittest.TestCase							):
				__a     :       Dict						=     (TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
				__a     :       Dict						=     (TFXGLMForCausalLM,) if is_tf_available() else ()
				__a     :       Union[str, Any]						=     (
				    {"feature-extraction": TFXGLMModel, "text-generation": TFXGLMForCausalLM} if is_tf_available() else {}
				)
				__a     :       Dict						=     False
				__a     :       Union[str, Any]						=     False
				__a     :       List[str]						=     False






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : int					  =      TFXGLMModelTester(self )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      ConfigTester(self      ,config_class=snake_case__      ,n_embd=37 )






				def 		snake_case	(			self ):
							self.config_tester.run_common_tests()






				@slow
				def 		snake_case	(			self ):
							for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      TFXGLMModel.from_pretrained(snake_case__ )
										self.assertIsNotNone(snake_case__ )






				@unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.' )
				def 		snake_case	(			self ):
							super().test_resize_token_embeddings()







@require_tf
class 				lowerCAmelCase_       (					unittest.TestCase							):






				@slow
				def 		snake_case	(			self      ,snake_case__=True ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' )
							SCREAMING_SNAKE_CASE_   : Any					  =      tf.convert_to_tensor([[2, 268, 9865]]      ,dtype=tf.intaa )  # The dog
							# </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
							# fmt: off
							SCREAMING_SNAKE_CASE_   : Tuple					  =      [2, 268, 9865, 67, 11, 1988, 57252, 9865, 5, 984, 67, 1988, 213838, 1658, 53, 70446, 33, 6657, 278, 1581]
							# fmt: on
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      model.generate(snake_case__      ,do_sample=snake_case__      ,num_beams=1 )
							if verify_outputs:
										self.assertListEqual(output_ids[0].numpy().tolist()      ,snake_case__ )






				@slow
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      XGLMTokenizer.from_pretrained('facebook/xglm-564M' )
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' )

							tf.random.set_seed(0 )
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tokenizer('Today is a nice day and'      ,return_tensors='tf' )
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      tokenized.input_ids
							# forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
							with tf.device(':/CPU:0' ):
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      model.generate(snake_case__      ,do_sample=snake_case__      ,seed=[7, 0] )
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      tokenizer.decode(output_ids[0]      ,skip_special_tokens=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      (
							    'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due'
							)
							self.assertEqual(snake_case__      ,snake_case__ )






				@slow
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      XGLMTokenizer.from_pretrained('facebook/xglm-564M' )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      'left'

							# use different length sentences to test batching
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      [
							    'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
							    'left-padding, such as in batched generation. The output for the sequence below should be the same '
							    'regardless of whether left padding is applied or not. When',
							    'Hello, my dog is a little',
							]

							SCREAMING_SNAKE_CASE_   : Any					  =      tokenizer(snake_case__      ,return_tensors='tf'      ,padding=snake_case__ )
							SCREAMING_SNAKE_CASE_   : int					  =      inputs['input_ids']

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      model.generate(input_ids=snake_case__      ,attention_mask=inputs['attention_mask']      ,max_new_tokens=12 )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      tokenizer(sentences[0]      ,return_tensors='tf' ).input_ids
							SCREAMING_SNAKE_CASE_   : Any					  =      model.generate(input_ids=snake_case__      ,max_new_tokens=12 )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      tokenizer(sentences[1]      ,return_tensors='tf' ).input_ids
							SCREAMING_SNAKE_CASE_   : Any					  =      model.generate(input_ids=snake_case__      ,max_new_tokens=12 )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      tokenizer.batch_decode(snake_case__      ,skip_special_tokens=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      tokenizer.decode(output_non_padded[0]      ,skip_special_tokens=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      tokenizer.decode(output_padded[0]      ,skip_special_tokens=snake_case__ )

							SCREAMING_SNAKE_CASE_   : str					  =      [
							    'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
							    'left-padding, such as in batched generation. The output for the sequence below should be the same '
							    'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be '
							    'a single',
							    'Hello, my dog is a little bit of a shy one, but he is very friendly',
							]
							self.assertListEqual(snake_case__      ,snake_case__ )
							self.assertListEqual(snake_case__      ,[non_padded_sentence, padded_sentence] )











import unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				lowercase__											=			MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
				lowercase__											=			TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       Optional[Any],    lowerCamelCase		:       Any,    lowerCamelCase		:       Tuple    ):

								'''simple docstring'''
								lowercase__  					=     AudioClassificationPipeline(model=lowerCamelCase,    feature_extractor=lowerCamelCase    )

								# test with a raw waveform
								lowercase__  					=     np.zeros((34_000,)    )
								lowercase__  					=     np.zeros((14_000,)    )
								return audio_classifier, [audioa, audio]




				def 							lowercase__  (	self		:       str,    lowerCamelCase		:       Dict,    lowerCamelCase		:       Union[str, Any]    ):

								'''simple docstring'''
								lowercase__					,		lowercase__  					=     examples
								lowercase__  					=     audio_classifier(lowerCamelCase    )
								# by default a model is initialized with num_labels=2
								self.assertEqual(
								    lowerCamelCase,    [
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								    ],    )
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=1    )
								self.assertEqual(
								    lowerCamelCase,    [
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								    ],    )

								self.run_torchaudio(lowerCamelCase    )




				@require_torchaudio
				def 							lowercase__  (	self		:       Optional[int],    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								import datasets

								# test with a local file
								lowercase__  					=     datasets.load_dataset('''hf-internal-testing/librispeech_asr_dummy''',    '''clean''',    split='''validation'''    )
								lowercase__  					=     dataset[0]['''audio''']['''array''']
								lowercase__  					=     audio_classifier(lowerCamelCase    )
								self.assertEqual(
								    lowerCamelCase,    [
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								    ],    )




				@require_torch
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								lowercase__  					=     '''anton-l/wav2vec2-random-tiny-classifier'''

								lowercase__  					=     pipeline('''audio-classification''',    model=lowerCamelCase    )

								lowercase__  					=     np.ones((8_000,)    )
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=4    )

								lowercase__  					=     [
								    {'''score''': 0.0842, '''label''': '''no'''},
								    {'''score''': 0.0838, '''label''': '''up'''},
								    {'''score''': 0.0837, '''label''': '''go'''},
								    {'''score''': 0.0834, '''label''': '''right'''},
								]
								lowercase__  					=     [
								    {'''score''': 0.0845, '''label''': '''stop'''},
								    {'''score''': 0.0844, '''label''': '''on'''},
								    {'''score''': 0.0841, '''label''': '''right'''},
								    {'''score''': 0.0834, '''label''': '''left'''},
								]
								self.assertIn(nested_simplify(lowerCamelCase,    decimals=4    ),    [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]    )

								lowercase__  					=     {'''array''': np.ones((8_000,)    ), '''sampling_rate''': audio_classifier.feature_extractor.sampling_rate}
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=4    )
								self.assertIn(nested_simplify(lowerCamelCase,    decimals=4    ),    [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]    )




				@require_torch
				@slow
				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								import datasets

								lowercase__  					=     '''superb/wav2vec2-base-superb-ks'''

								lowercase__  					=     pipeline('''audio-classification''',    model=lowerCamelCase    )
								lowercase__  					=     datasets.load_dataset('''anton-l/superb_dummy''',    '''ks''',    split='''test'''    )

								lowercase__  					=     np.array(dataset[3]['''speech'''],    dtype=np.floataa    )
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=4    )
								self.assertEqual(
								    nested_simplify(lowerCamelCase,    decimals=3    ),    [
								        {'''score''': 0.981, '''label''': '''go'''},
								        {'''score''': 0.007, '''label''': '''up'''},
								        {'''score''': 0.006, '''label''': '''_unknown_'''},
								        {'''score''': 0.001, '''label''': '''down'''},
								    ],    )




				@require_tf
				@unittest.skip('''Audio classification is not implemented for TF'''    )
				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								pass




