

'''simple docstring'''
from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 import (
         TFRoFormerForCausalLM,
         TFRoFormerForMaskedLM,
         TFRoFormerForMultipleChoice,
         TFRoFormerForQuestionAnswering,
         TFRoFormerForSequenceClassification,
         TFRoFormerForTokenClassification,
         TFRoFormerModel,
     )
     from transformers.models.roformer.modeling_tf_roformer import (
         TFRoFormerSelfAttention,
         TFRoFormerSinusoidalPositionalEmbedding,
     )







class 							A__   :





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =parent
       _SCREAMING_SNAKE_CASE							   =13
       _SCREAMING_SNAKE_CASE							   =7
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =99
       _SCREAMING_SNAKE_CASE							   =32
       _SCREAMING_SNAKE_CASE							   =2
       _SCREAMING_SNAKE_CASE							   =4
       _SCREAMING_SNAKE_CASE							   =37
       _SCREAMING_SNAKE_CASE							   ='gelu'
       _SCREAMING_SNAKE_CASE							   =0.1
       _SCREAMING_SNAKE_CASE							   =0.1
       _SCREAMING_SNAKE_CASE							   =512
       _SCREAMING_SNAKE_CASE							   =16
       _SCREAMING_SNAKE_CASE							   =2
       _SCREAMING_SNAKE_CASE							   =0.02
       _SCREAMING_SNAKE_CASE							   =3
       _SCREAMING_SNAKE_CASE							   =4
       _SCREAMING_SNAKE_CASE							   =None





  def 						A  (		self				:     Union[str, Any]			)     ->   List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size, self.seq_length]							, self.vocab_size			)

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

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

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

       _SCREAMING_SNAKE_CASE							   =RoFormerConfig(
           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							, initializer_range=self.initializer_range							, return_dict=_a							, )

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





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFRoFormerModel(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

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

       _SCREAMING_SNAKE_CASE							   =model(_a			)

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





  def 						A  (		self				:     Tuple							, _a				:     Optional[int]							, _a				:     Any							, _a				:     List[Any]							, _a				:     Any							, _a				:     Optional[Any]							, _a				:     Optional[int]							, _a				:     Any			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =TFRoFormerForCausalLM(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							   =model(_a			)['logits']
       self.parent.assertListEqual(
           list(prediction_scores.numpy().shape			)							, [self.batch_size, self.seq_length, self.vocab_size]			)





  def 						A  (		self				:     List[str]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     Tuple							, _a				:     Dict							, _a				:     Union[str, Any]							, _a				:     Any							, _a				:     Optional[Any]			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFRoFormerForMaskedLM(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							   =model(_a			)
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.seq_length, self.vocab_size)			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.num_labels
       _SCREAMING_SNAKE_CASE							   =TFRoFormerForSequenceClassification(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       _SCREAMING_SNAKE_CASE							   =model(_a			)
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)			)





  def 						A  (		self				:     Tuple							, _a				:     Tuple							, _a				:     List[Any]							, _a				:     Tuple							, _a				:     Optional[Any]							, _a				:     Tuple							, _a				:     Optional[Any]							, _a				:     int			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.num_choices
       _SCREAMING_SNAKE_CASE							   =TFRoFormerForMultipleChoice(config=_a			)
       _SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
       _SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
       _SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							   =model(_a			)
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_choices)			)





  def 						A  (		self				:     List[str]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     int							, _a				:     List[str]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     Optional[int]			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.num_labels
       _SCREAMING_SNAKE_CASE							   =TFRoFormerForTokenClassification(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       _SCREAMING_SNAKE_CASE							   =model(_a			)
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.seq_length, self.num_labels)			)





  def 						A  (		self				:     str							, _a				:     Union[str, Any]							, _a				:     Dict							, _a				:     Union[str, Any]							, _a				:     str							, _a				:     Union[str, Any]							, _a				:     str							, _a				:     int			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFRoFormerForQuestionAnswering(config=_a			)
       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       _SCREAMING_SNAKE_CASE							   =model(_a			)
       self.parent.assertEqual(result.start_logits.shape							, (self.batch_size, self.seq_length)			)
       self.parent.assertEqual(result.end_logits.shape							, (self.batch_size, self.seq_length)			)





  def 						A  (		self				:     int			)     ->   Any:





       '''simple docstring'''






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







@require_tf
class 							A__   (	A__					,       A__					,       unittest.TestCase  ):
  A__					=    (
      (
          TFRoFormerModel,
          TFRoFormerForCausalLM,
          TFRoFormerForMaskedLM,
          TFRoFormerForQuestionAnswering,
          TFRoFormerForSequenceClassification,
          TFRoFormerForTokenClassification,
          TFRoFormerForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  A__					=    (
      {
          'feature-extraction': TFRoFormerModel,
          'fill-mask': TFRoFormerForMaskedLM,
          'question-answering': TFRoFormerForQuestionAnswering,
          'text-classification': TFRoFormerForSequenceClassification,
          'text-generation': TFRoFormerForCausalLM,
          'token-classification': TFRoFormerForTokenClassification,
          'zero-shot': TFRoFormerForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )

  A__					=    False
  A__					=    False





  def 						A  (		self				:     Tuple							, _a				:     Optional[int]							, _a				:     str							, _a				:     str							, _a				:     Dict							, _a				:     List[Any]			)     ->   Optional[Any]:





       '''simple docstring'''






       if pipeline_test_casse_name == "TextGenerationPipelineTests":
            return True

       return False





  def 						A  (		self				:     Dict			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFRoFormerModelTester(self			)
       _SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=_a							, hidden_size=37			)





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





       '''simple docstring'''






       self.config_tester.run_common_tests()





  def 						A  (		self				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_a			)





  def 						A  (		self				:     Any			)     ->   Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_lm_head(*_a			)





  def 						A  (		self				:     List[Any]			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_a			)





  def 						A  (		self				:     List[Any]			)     ->   List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_a			)





  def 						A  (		self				:     Dict			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_a			)





  @slow
  def 						A  (		self				:     str			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base'			)
       self.assertIsNotNone(_a			)







@require_tf
class 							A__   (	unittest.TestCase  ):





  @slow
  def 						A  (		self				:     List[str]			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base'			)
       _SCREAMING_SNAKE_CASE							   =tf.constant([[0, 1, 2, 3, 4, 5]]			)
       _SCREAMING_SNAKE_CASE							   =model(_a			)[0]

       # TODO Replace vocab size
       _SCREAMING_SNAKE_CASE							   =5_0000

       _SCREAMING_SNAKE_CASE							   =[1, 6, vocab_size]
       self.assertEqual(output.shape							, _a			)

       print(output[:, :3, :3]			)

       # TODO Replace values below with what was printed above.
       _SCREAMING_SNAKE_CASE							   =tf.constant(
           [
               [
                   [-0.12_05_33_41, -1.0_26_49_01, 0.29_22_19_46],
                   [-1.5_13_37_83, 0.19_74_33, 0.15_19_06_07],
                   [-5.0_13_54_03, -3.90_02_56, -0.84_03_87_64],
               ]
           ]			)
       tf.debugging.assert_near(output[:, :3, :3]							, _a							, atol=1e-4			)







@require_tf
class 							A__   (	unittest.TestCase  ):
  A__					=    1E-4





  def 						A  (		self				:     int			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =tf.constant([[4, 10]]			)
       _SCREAMING_SNAKE_CASE							   =TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							, embedding_dim=6			)

       _SCREAMING_SNAKE_CASE							   =emba(input_ids.shape			)
       _SCREAMING_SNAKE_CASE							   =tf.constant(
           [[0.00_00, 0.00_00, 0.00_00, 1.00_00, 1.00_00, 1.00_00], [0.84_15, 0.04_64, 0.00_22, 0.54_03, 0.99_89, 1.00_00]]			)

       tf.debugging.assert_near(_a							, _a							, atol=self.tolerance			)





  def 						A  (		self				:     Dict			)     ->   List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =tf.constant(
           [
               [0.00_00, 0.00_00, 0.00_00, 0.00_00, 0.00_00],
               [0.84_15, 0.82_19, 0.80_20, 0.78_19, 0.76_17],
               [0.90_93, 0.93_64, 0.95_81, 0.97_49, 0.98_70],
           ]			)
       _SCREAMING_SNAKE_CASE							   =TFRoFormerSinusoidalPositionalEmbedding(num_positions=512							, embedding_dim=512			)
       emba([2, 16, 512]			)
       _SCREAMING_SNAKE_CASE							   =emba.weight[:3, :5]

       tf.debugging.assert_near(_a							, _a							, atol=self.tolerance			)







@require_tf
class 							A__   (	unittest.TestCase  ):
  A__					=    1E-4





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =tf.reshape(tf.range(2 * 12 * 16 * 64							, dtype=tf.floataa			)							, shape=(2, 12, 16, 64)			) / 100

       _SCREAMING_SNAKE_CASE							   =-tf.reshape(tf.range(2 * 12 * 16 * 64							, dtype=tf.floataa			)							, shape=(2, 12, 16, 64)			) / 100

       _SCREAMING_SNAKE_CASE							   =TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							, embedding_dim=64			)
       _SCREAMING_SNAKE_CASE							   =embed_positions([2, 16, 768]			)[None, None, :, :]

       _SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =TFRoFormerSelfAttention.apply_rotary_position_embeddings(
           _a							, _a							, _a			)

       _SCREAMING_SNAKE_CASE							   =tf.constant(
           [
               [0.00_00, 0.01_00, 0.02_00, 0.03_00, 0.04_00, 0.05_00, 0.06_00, 0.07_00],
               [-0.20_12, 0.88_97, 0.02_63, 0.94_01, 0.20_74, 0.94_63, 0.34_81, 0.93_43],
               [-1.70_57, 0.62_71, -1.21_45, 1.38_97, -0.63_03, 1.76_47, -0.11_73, 1.89_85],
               [-2.17_31, -1.63_97, -2.73_58, 0.28_54, -2.18_40, 1.71_83, -1.30_18, 2.48_71],
               [0.27_17, -3.61_73, -2.92_06, -2.19_88, -3.66_38, 0.38_58, -2.91_55, 2.29_80],
               [3.98_59, -2.15_80, -0.79_84, -4.49_04, -4.11_81, -2.02_52, -4.47_82, 1.12_53],
           ]			)
       _SCREAMING_SNAKE_CASE							   =tf.constant(
           [
               [0.00_00, -0.01_00, -0.02_00, -0.03_00, -0.04_00, -0.05_00, -0.06_00, -0.07_00],
               [0.20_12, -0.88_97, -0.02_63, -0.94_01, -0.20_74, -0.94_63, -0.34_81, -0.93_43],
               [1.70_57, -0.62_71, 1.21_45, -1.38_97, 0.63_03, -1.76_47, 0.11_73, -1.89_85],
               [2.17_31, 1.63_97, 2.73_58, -0.28_54, 2.18_40, -1.71_83, 1.30_18, -2.48_71],
               [-0.27_17, 3.61_73, 2.92_06, 2.19_88, 3.66_38, -0.38_58, 2.91_55, -2.29_80],
               [-3.98_59, 2.15_80, 0.79_84, 4.49_04, 4.11_81, 2.02_52, 4.47_82, -1.12_53],
           ]			)

       tf.debugging.assert_near(query_layer[0, 0, :6, :8]							, _a							, atol=self.tolerance			)
       tf.debugging.assert_near(key_layer[0, 0, :6, :8]							, _a							, atol=self.tolerance			)



'''simple docstring'''
import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin







class 							A__   (	A__  ):
  A__					=    'MCTCTFeatureExtractor'
  A__					=    'AutoTokenizer'





  def __init__(		self				:     Optional[Any]							, _a				:     Optional[int]							, _a				:     Union[str, Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       super().__init__(_a							, _a			)
       _SCREAMING_SNAKE_CASE							   =self.feature_extractor
       _SCREAMING_SNAKE_CASE							   =False





  def __call__(		self				:     Dict							, *_a				:     str							, **_a				:     Dict			)     ->   Dict:





       '''simple docstring'''






       if self._in_target_context_manager:
            return self.current_processor(*_a							, **_a			)

       if "raw_speech" in kwargs:
            warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'			)
            _SCREAMING_SNAKE_CASE							   =kwargs.pop('raw_speech'			)
       else:
            _SCREAMING_SNAKE_CASE							   =kwargs.pop('audio'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('sampling_rate'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('text'							, _a			)
       if len(_a			) > 0:
            _SCREAMING_SNAKE_CASE							   =args[0]
            _SCREAMING_SNAKE_CASE							   =args[1:]

       if audio is None and text is None:
            raise ValueError('You need to specify either an `audio` or `text` input to process.'			)

       if audio is not None:
            _SCREAMING_SNAKE_CASE							   =self.feature_extractor(_a							, *_a							, sampling_rate=_a							, **_a			)
       if text is not None:
            _SCREAMING_SNAKE_CASE							   =self.tokenizer(_a							, **_a			)

       if text is None:
            return inputs
       elif audio is None:
            return encodings
       else:
            _SCREAMING_SNAKE_CASE							   =encodings['input_ids']
            return inputs





  def 						A  (		self				:     Any							, *_a				:     List[str]							, **_a				:     Optional[int]			)     ->   Optional[int]:





       '''simple docstring'''






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





  def 						A  (		self				:     Dict							, *_a				:     Tuple							, **_a				:     Dict			)     ->   List[str]:





       '''simple docstring'''






       if self._in_target_context_manager:
            return self.current_processor.pad(*_a							, **_a			)

       _SCREAMING_SNAKE_CASE							   =kwargs.pop('input_features'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('labels'							, _a			)
       if len(_a			) > 0:
            _SCREAMING_SNAKE_CASE							   =args[0]
            _SCREAMING_SNAKE_CASE							   =args[1:]

       if input_features is not None:
            _SCREAMING_SNAKE_CASE							   =self.feature_extractor.pad(_a							, *_a							, **_a			)
       if labels is not None:
            _SCREAMING_SNAKE_CASE							   =self.tokenizer.pad(_a							, **_a			)

       if labels is None:
            return input_features
       elif input_features is None:
            return labels
       else:
            _SCREAMING_SNAKE_CASE							   =labels['input_ids']
            return input_features





  def 						A  (		self				:     Tuple							, *_a				:     Dict							, **_a				:     List[Any]			)     ->   Optional[int]:





       '''simple docstring'''






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





  @contextmanager
  def 						A  (		self				:     Optional[Any]			)     ->   Dict:





       '''simple docstring'''






       warnings.warn(
           '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
           'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
           'your audio inputs, or in a separate call.'			)
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =self.tokenizer
       yield
       _SCREAMING_SNAKE_CASE							   =self.feature_extractor
       _SCREAMING_SNAKE_CASE							   =False
