




import unittest

from parameterized import parameterized

from transformers import LlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer


class 				UpperCamelCase_    :

    '''simple docstring'''






    def __init__(			self      :	Dict					, UpperCAmelCase__      :	int					, UpperCAmelCase__      :	Optional[int]=13					, UpperCAmelCase__      :	int=7					, UpperCAmelCase__      :	Any=True					, UpperCAmelCase__      :	List[Any]=True					, UpperCAmelCase__      :	List[Any]=False					, UpperCAmelCase__      :	Tuple=True					, UpperCAmelCase__      :	List[str]=99					, UpperCAmelCase__      :	str=32					, UpperCAmelCase__      :	Union[str, Any]=5					, UpperCAmelCase__      :	Dict=4					, UpperCAmelCase__      :	List[str]=37					, UpperCAmelCase__      :	int="gelu"					, UpperCAmelCase__      :	List[Any]=0.1					, UpperCAmelCase__      :	Tuple=0.1					, UpperCAmelCase__      :	Any=512					, UpperCAmelCase__      :	List[str]=16					, UpperCAmelCase__      :	Dict=2					, UpperCAmelCase__      :	str=0.02					, UpperCAmelCase__      :	Any=3					, UpperCAmelCase__      :	str=4					, UpperCAmelCase__      :	Optional[int]=None					, )						->Optional[int]:





           '''simple docstring'''

           A__       =    parent
           A__       =    batch_size
           A__       =    seq_length
           A__       =    is_training
           A__       =    use_input_mask
           A__       =    use_token_type_ids
           A__       =    use_labels
           A__       =    vocab_size
           A__       =    hidden_size
           A__       =    num_hidden_layers
           A__       =    num_attention_heads
           A__       =    intermediate_size
           A__       =    hidden_act
           A__       =    hidden_dropout_prob
           A__       =    attention_probs_dropout_prob
           A__       =    max_position_embeddings
           A__       =    type_vocab_size
           A__       =    type_sequence_label_size
           A__       =    initializer_range
           A__       =    num_labels
           A__       =    num_choices
           A__       =    scope


    def        SCREAMING_SNAKE_CASE							(			self      :	List[Any])						->Any:





           '''simple docstring'''

           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
           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__       =    self.get_config()

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


    def        SCREAMING_SNAKE_CASE							(			self      :	int)						->List[str]:





           '''simple docstring'''

           return LlamaConfig(
               vocab_size=self.vocab_size					, hidden_size=self.hidden_size					, num_hidden_layers=self.num_hidden_layers					, num_attention_heads=self.num_attention_heads					, intermediate_size=self.intermediate_size					, hidden_act=self.hidden_act					, hidden_dropout_prob=self.hidden_dropout_prob					, attention_probs_dropout_prob=self.attention_probs_dropout_prob					, max_position_embeddings=self.max_position_embeddings					, type_vocab_size=self.type_vocab_size					, is_decoder=UpperCAmelCase__					, initializer_range=self.initializer_range					, )


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, UpperCAmelCase__      :	List[str]					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	str					, UpperCAmelCase__      :	int					, UpperCAmelCase__      :	int					, UpperCAmelCase__      :	str)						->Any:





           '''simple docstring'''

           A__       =    LlamaModel(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__					, attention_mask=UpperCAmelCase__)
           A__       =    model(UpperCAmelCase__)
           self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.hidden_size))


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	int					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	Tuple					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	Optional[int]					, UpperCAmelCase__      :	List[Any]					, UpperCAmelCase__      :	str					, )						->Dict:





           '''simple docstring'''

           A__       =    True
           A__       =    LlamaModel(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(
               UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, encoder_hidden_states=UpperCAmelCase__					, encoder_attention_mask=UpperCAmelCase__					, )
           A__       =    model(
               UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, encoder_hidden_states=UpperCAmelCase__					, )
           A__       =    model(UpperCAmelCase__					, attention_mask=UpperCAmelCase__)
           self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.hidden_size))


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, UpperCAmelCase__      :	str					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	str					, UpperCAmelCase__      :	int					, UpperCAmelCase__      :	List[str]					, UpperCAmelCase__      :	Optional[int]					, UpperCAmelCase__      :	Tuple					, UpperCAmelCase__      :	str					, UpperCAmelCase__      :	Any					, )						->Any:





           '''simple docstring'''

           A__       =    LlamaForCausalLM(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, labels=UpperCAmelCase__)
           self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.seq_length, self.vocab_size))


    def        SCREAMING_SNAKE_CASE							(			self      :	str					, UpperCAmelCase__      :	Tuple					, UpperCAmelCase__      :	Optional[Any]					, UpperCAmelCase__      :	str					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	int					, UpperCAmelCase__      :	str					, UpperCAmelCase__      :	Any					, UpperCAmelCase__      :	Union[str, Any]					, UpperCAmelCase__      :	str					, )						->Any:





           '''simple docstring'''

           A__       =    True
           A__       =    True
           A__       =    LlamaForCausalLM(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()

           # first forward pass
           A__       =    model(
               UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, encoder_hidden_states=UpperCAmelCase__					, encoder_attention_mask=UpperCAmelCase__					, use_cache=UpperCAmelCase__					, )
           A__       =    outputs.past_key_values

           # create hypothetical multiple next token and extent to next_input_ids
           A__       =    ids_tensor((self.batch_size, 3)					, config.vocab_size)
           A__       =    ids_tensor((self.batch_size, 3)					, vocab_size=2)

           # append to next input_ids and
           A__       =    torch.cat([input_ids, next_tokens]					, dim=-1)
           A__       =    torch.cat([input_mask, next_mask]					, dim=-1)

           A__       =    model(
               UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, encoder_hidden_states=UpperCAmelCase__					, encoder_attention_mask=UpperCAmelCase__					, output_hidden_states=UpperCAmelCase__					, )['''hidden_states'''][0]
           A__       =    model(
               UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, encoder_hidden_states=UpperCAmelCase__					, encoder_attention_mask=UpperCAmelCase__					, past_key_values=UpperCAmelCase__					, output_hidden_states=UpperCAmelCase__					, )['''hidden_states'''][0]

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

           self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1])

           # test that outputs are equal for slice
           self.parent.assertTrue(torch.allclose(UpperCAmelCase__					, UpperCAmelCase__					, atol=1e-3))





    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any])						->List[Any]:





           '''simple docstring'''

           A__       =    self.prepare_config_and_inputs()
           (
               (
               A__
           ) ,							(
               A__
           ) ,							(
               A__
           ) ,							(
               A__
           ) ,							(
               A__
           ) ,							(
               A__
           ) ,							(
               A__
           ) ,							
           )       =    config_and_inputs
           A__       =    {'''input_ids''': input_ids, '''attention_mask''': input_mask}
           return config, inputs_dict


@require_torch
class 				UpperCamelCase_    ( UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					unittest.TestCase     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
    UpperCAmelCase__							  =      (LlamaForCausalLM,) if is_torch_available() else ()
    UpperCAmelCase__							  =      (
        {
            '''feature-extraction''': LlamaModel,
            '''text-classification''': LlamaForSequenceClassification,
            '''text-generation''': LlamaForCausalLM,
            '''zero-shot''': LlamaForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    UpperCAmelCase__							  =      False
    UpperCAmelCase__							  =      False


    def        SCREAMING_SNAKE_CASE							(			self      :	List[Any])						->int:





           '''simple docstring'''

           A__       =    LlamaModelTester(self)
           A__       =    ConfigTester(self					, config_class=UpperCAmelCase__					, hidden_size=37)


    def        SCREAMING_SNAKE_CASE							(			self      :	Tuple)						->Optional[int]:





           '''simple docstring'''

           self.config_tester.run_common_tests()


    def        SCREAMING_SNAKE_CASE							(			self      :	str)						->List[str]:





           '''simple docstring'''

           A__       =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCAmelCase__)


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[int])						->Tuple:





           '''simple docstring'''

           A__       =    self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
                  A__       =    type
                  self.model_tester.create_and_check_model(*UpperCAmelCase__)


    def        SCREAMING_SNAKE_CASE							(			self      :	List[Any])						->Optional[int]:





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()
           A__       =    3
           A__       =    input_dict['''input_ids''']
           A__       =    input_ids.ne(1).to(UpperCAmelCase__)
           A__       =    ids_tensor([self.model_tester.batch_size]					, self.model_tester.type_sequence_label_size)
           A__       =    LlamaForSequenceClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, labels=UpperCAmelCase__)
           self.assertEqual(result.logits.shape					, (self.model_tester.batch_size, self.model_tester.num_labels))


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[int])						->List[str]:





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()
           A__       =    3
           A__       =    '''single_label_classification'''
           A__       =    input_dict['''input_ids''']
           A__       =    input_ids.ne(1).to(UpperCAmelCase__)
           A__       =    ids_tensor([self.model_tester.batch_size]					, self.model_tester.type_sequence_label_size)
           A__       =    LlamaForSequenceClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, labels=UpperCAmelCase__)
           self.assertEqual(result.logits.shape					, (self.model_tester.batch_size, self.model_tester.num_labels))


    def        SCREAMING_SNAKE_CASE							(			self      :	Any)						->Tuple:





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()
           A__       =    3
           A__       =    '''multi_label_classification'''
           A__       =    input_dict['''input_ids''']
           A__       =    input_ids.ne(1).to(UpperCAmelCase__)
           A__       =    ids_tensor(
               [self.model_tester.batch_size, config.num_labels]					, self.model_tester.type_sequence_label_size).to(torch.float)
           A__       =    LlamaForSequenceClassification(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__       =    model(UpperCAmelCase__					, attention_mask=UpperCAmelCase__					, labels=UpperCAmelCase__)
           self.assertEqual(result.logits.shape					, (self.model_tester.batch_size, self.model_tester.num_labels))


    @unittest.skip('''LLaMA buffers include complex numbers, which breaks this test''')
    def        SCREAMING_SNAKE_CASE							(			self      :	Any)						->int:





           '''simple docstring'''

           pass





    @parameterized.expand([('''linear''',), ('''dynamic''',)])
    def        SCREAMING_SNAKE_CASE							(			self      :	Any					, UpperCAmelCase__      :	Optional[int])						->List[str]:





           '''simple docstring'''

           A__ ,							A__       =    self.model_tester.prepare_config_and_inputs_for_common()
           A__       =    ids_tensor([1, 10]					, config.vocab_size)
           A__       =    ids_tensor([1, int(config.max_position_embeddings * 1.5)]					, config.vocab_size)

           set_seed(42)  # Fixed seed at init time so the two models get the same random weights
           A__       =    LlamaModel(UpperCAmelCase__)
           original_model.to(UpperCAmelCase__)
           original_model.eval()
           A__       =    original_model(UpperCAmelCase__).last_hidden_state
           A__       =    original_model(UpperCAmelCase__).last_hidden_state

           set_seed(42)  # Fixed seed at init time so the two models get the same random weights
           A__       =    {'''type''': scaling_type, '''factor''': 10.0}
           A__       =    LlamaModel(UpperCAmelCase__)
           scaled_model.to(UpperCAmelCase__)
           scaled_model.eval()
           A__       =    scaled_model(UpperCAmelCase__).last_hidden_state
           A__       =    scaled_model(UpperCAmelCase__).last_hidden_state

           # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
           # maximum sequence length, so the outputs for the short input should match.
           if scaling_type == "dynamic":
                  self.assertTrue(torch.allclose(UpperCAmelCase__					, UpperCAmelCase__					, atol=1e-5))
           else:
                  self.assertFalse(torch.allclose(UpperCAmelCase__					, UpperCAmelCase__					, atol=1e-5))

           # The output should be different for long inputs
           self.assertFalse(torch.allclose(UpperCAmelCase__					, UpperCAmelCase__					, atol=1e-5))


@require_torch
class 				UpperCamelCase_    ( unittest.TestCase     ):

    '''simple docstring'''






    @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''')
    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Union[str, Any]:





           '''simple docstring'''

           A__       =    [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           A__       =    LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-7b-hf'''					, device_map='''auto''')
           A__       =    model(torch.tensor([input_ids]))
           # Expected mean on dim = -1
           A__       =    torch.tensor([[-6.6550, -4.1227, -4.9859, -3.2406, 0.8262, -3.0033, 1.2964, -3.3699]])
           torch.testing.assert_close(out.mean(-1)					, UpperCAmelCase__					, atol=1e-2					, rtol=1e-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           A__       =    torch.tensor([-12.8281, -7.4453, -0.4639, -8.0625, -7.2500, -8.0000, -6.4883, -7.7695, -7.8438, -7.0312, -6.2188, -7.1328, -1.8496, 1.9961, -8.6250, -6.7227, -12.8281, -6.9492, -7.0742, -7.7852, -7.5820, -7.9062, -6.9375, -7.9805, -8.3438, -8.1562, -8.0469, -7.6250, -7.7422, -7.3398,])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30]					, UpperCAmelCase__					, atol=1e-5					, rtol=1e-5)


    @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''')
    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	List[Any])						->str:





           '''simple docstring'''

           A__       =    [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           A__       =    LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-hf'''					, device_map='''auto''')
           A__       =    model(torch.tensor(UpperCAmelCase__))
           # Expected mean on dim = -1
           A__       =    torch.tensor([[-2.0622, -1.2794, -1.1638, -0.9788, -1.4603, -1.0238, -1.7893, -1.4411]])
           torch.testing.assert_close(out.mean(-1)					, UpperCAmelCase__					, atol=1e-2					, rtol=1e-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           A__       =    torch.tensor([-8.1406, -8.0547, 2.7461, -1.2344, -0.1448, -1.8262, -1.0020, -1.8154, -1.6895, -1.8516, -2.3574, -0.9277, 3.7598, 6.5742, -1.2998, -0.1177, -8.1406, -2.9688, -2.9199, -3.1699, -3.5254, -2.3555, -2.7988, -3.4141, -2.8262, -4.5195, -3.3379, -3.3164, -2.7832, -3.0273])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30]					, UpperCAmelCase__					, atol=1e-5					, rtol=1e-5)


    @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''')
    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	Tuple)						->Any:





           '''simple docstring'''

           A__       =    [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           A__       =    LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''					, device_map='''auto''')
           A__       =    model(torch.tensor(UpperCAmelCase__))
           # Expected mean on dim = -1
           A__       =    torch.tensor([[-0.8562, -1.8520, -0.7551, -0.4162, -1.5161, -1.2038, -2.4823, -2.3254]])
           torch.testing.assert_close(out.mean(-1)					, UpperCAmelCase__					, atol=1e-2					, rtol=1e-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           A__       =    torch.tensor([-2.2227, 4.8828, 0.9023, -0.4578, -0.7871, -0.1033, -0.6221, -0.5786, -0.7803, -1.0674, -1.2920, -0.1570, 0.8008, 2.0723, -0.9497, 0.2771, -2.2227, -0.7612, -1.4346, -1.2061, -1.6426, -0.3000, -0.7139, -1.1934, -1.8691, -1.6973, -1.5947, -1.2705, -0.3523, -0.5513])
           # fmt: on
           torch.testing.assert_close(out.mean(-1)					, UpperCAmelCase__					, atol=1e-2					, rtol=1e-2)


    @unittest.skip(
        '''Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test''')
    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Dict:





           '''simple docstring'''

           A__       =    [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           A__       =    LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-70b-hf'''					, device_map='''auto''')
           A__       =    model(torch.tensor(UpperCAmelCase__))

           A__       =    torch.tensor(
               [[-4.2327, -3.3360, -4.6665, -4.7631, -1.8180, -3.4170, -1.4211, -3.1810]]					, dtype=torch.floataa)
           torch.testing.assert_close(out.mean(-1)					, UpperCAmelCase__					, atol=1e-2					, rtol=1e-2)
           # fmt: off
           A__       =    torch.tensor([-9.4922, -3.9551, 1.7998, -5.6758, -5.1055, -5.8984, -4.8320, -6.8086, -6.5391, -5.6172, -5.5820, -5.5352, 1.7881, 3.6289, -6.5117, -3.4785, -9.5000, -6.0352, -6.8125, -6.0195, -6.6836, -5.4727, -6.2812, -6.0391, -7.3398, -7.4297, -7.4844, -6.5820, -5.8789, -5.5312])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30]					, UpperCAmelCase__					, atol=1e-5					, rtol=1e-5)





    @unittest.skip('''Model is curently gated''')
    @slow
    def        SCREAMING_SNAKE_CASE							(			self      :	int)						->Optional[Any]:





           '''simple docstring'''

           A__       =    '''Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the "princi'''
           A__       =    '''Simply put, the theory of relativity states that '''
           A__       =    LlamaTokenizer.from_pretrained('''meta-llama/Llama-2-13b-chat-hf''')
           A__       =    tokenizer.encode(UpperCAmelCase__					, return_tensors='''pt''')
           A__       =    LlamaForCausalLM.from_pretrained(
               '''meta-llama/Llama-2-13b-chat-hf'''					, device_map='''sequential'''					, use_safetensors=UpperCAmelCase__)

           # greedy generation outputs
           A__       =    model.generate(UpperCAmelCase__					, max_new_tokens=64					, top_p=UpperCAmelCase__					, temperature=1					, do_sample=UpperCAmelCase__)
           A__       =    tokenizer.decode(generated_ids[0]					, skip_special_tokens=UpperCAmelCase__)
           self.assertEqual(UpperCAmelCase__					, UpperCAmelCase__)








from ...processing_utils import ProcessorMixin


class 				UpperCamelCase_    ( UpperCAmelCase__     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      '''SpeechT5FeatureExtractor'''
    UpperCAmelCase__							  =      '''SpeechT5Tokenizer'''


    def __init__(			self      :	Any					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	Tuple)						->Union[str, Any]:





           '''simple docstring'''

           super().__init__(UpperCAmelCase__					, UpperCAmelCase__)


    def __call__(			self      :	Dict					, *UpperCAmelCase__      :	List[str]					, **UpperCAmelCase__      :	Any)						->Optional[Any]:





           '''simple docstring'''

           A__       =    kwargs.pop('''audio'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''text'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''text_target'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''audio_target'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''sampling_rate'''					, UpperCAmelCase__)

           if audio is not None and text is not None:
                  raise ValueError(
                      '''Cannot process both `audio` and `text` inputs. Did you mean `audio_target` or `text_target`?''')
           if audio_target is not None and text_target is not None:
                  raise ValueError(
                      '''Cannot process both `audio_target` and `text_target` inputs. Did you mean `audio` or `text`?''')
           if audio is None and audio_target is None and text is None and text_target is None:
                  raise ValueError(
                      '''You need to specify either an `audio`, `audio_target`, `text`, or `text_target` input to process.''')

           if audio is not None:
                  A__       =    self.feature_extractor(UpperCAmelCase__					, *UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, **UpperCAmelCase__)
           elif text is not None:
                  A__       =    self.tokenizer(UpperCAmelCase__					, **UpperCAmelCase__)
           else:
                  A__       =    None

           if audio_target is not None:
                  A__       =    self.feature_extractor(audio_target=UpperCAmelCase__					, *UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, **UpperCAmelCase__)
                  A__       =    targets['''input_values''']
           elif text_target is not None:
                  A__       =    self.tokenizer(UpperCAmelCase__					, **UpperCAmelCase__)
                  A__       =    targets['''input_ids''']
           else:
                  A__       =    None

           if inputs is None:
                  return targets

           if targets is not None:
                  A__       =    labels

                  A__       =    targets.get('''attention_mask''')
                  if decoder_attention_mask is not None:
                         A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, *UpperCAmelCase__      :	Tuple					, **UpperCAmelCase__      :	int)						->Optional[int]:





           '''simple docstring'''

           A__       =    kwargs.pop('''input_values'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''input_ids'''					, UpperCAmelCase__)
           A__       =    kwargs.pop('''labels'''					, UpperCAmelCase__)

           if input_values is not None and input_ids is not None:
                  raise ValueError('''Cannot process both `input_values` and `input_ids` inputs.''')
           if input_values is None and input_ids is None and labels is None:
                  raise ValueError(
                      '''You need to specify either an `input_values`, `input_ids`, or `labels` input to be padded.''')

           if input_values is not None:
                  A__       =    self.feature_extractor.pad(UpperCAmelCase__					, *UpperCAmelCase__					, **UpperCAmelCase__)
           elif input_ids is not None:
                  A__       =    self.tokenizer.pad(UpperCAmelCase__					, **UpperCAmelCase__)
           else:
                  A__       =    None

           if labels is not None:
                  if "input_ids" in labels or (isinstance(UpperCAmelCase__					, UpperCAmelCase__) and "input_ids" in labels[0]):
                         A__       =    self.tokenizer.pad(UpperCAmelCase__					, **UpperCAmelCase__)
                         A__       =    targets['''input_ids''']
                  else:
                         A__       =    self.feature_extractor.feature_size
                         A__       =    self.feature_extractor.num_mel_bins
                         A__       =    self.feature_extractor.pad(UpperCAmelCase__					, *UpperCAmelCase__					, **UpperCAmelCase__)
                         A__       =    feature_size_hack
                         A__       =    targets['''input_values''']
           else:
                  A__       =    None

           if inputs is None:
                  return targets

           if targets is not None:
                  A__       =    labels

                  A__       =    targets.get('''attention_mask''')
                  if decoder_attention_mask is not None:
                         A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	Any					, *UpperCAmelCase__      :	Dict					, **UpperCAmelCase__      :	Optional[Any])						->Optional[Any]:





           '''simple docstring'''

           return self.tokenizer.batch_decode(*UpperCAmelCase__					, **UpperCAmelCase__)





    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, *UpperCAmelCase__      :	List[Any]					, **UpperCAmelCase__      :	Union[str, Any])						->Dict:





           '''simple docstring'''

           return self.tokenizer.decode(*UpperCAmelCase__					, **UpperCAmelCase__)


