


import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


_A		:				Union[str, Any]									=       1e-4

if is_torch_available():
   import torch

   from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
   from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder







@require_torch
class        a					:





     def __init__(    self					:				Optional[Any]    ,	SCREAMING_SNAKE_CASE_					:				str    ,	SCREAMING_SNAKE_CASE_					:				Optional[Any]=16    ,	SCREAMING_SNAKE_CASE_					:				List[Any]=13    ,	SCREAMING_SNAKE_CASE_					:				Tuple=7    ,	SCREAMING_SNAKE_CASE_					:				Tuple=14    ,	SCREAMING_SNAKE_CASE_					:				Tuple=10    ,	SCREAMING_SNAKE_CASE_					:				List[str]=19    ,	SCREAMING_SNAKE_CASE_					:				Optional[int]=5    ,	SCREAMING_SNAKE_CASE_					:				List[str]=4    ,	SCREAMING_SNAKE_CASE_					:				Optional[Any]=True    ,	SCREAMING_SNAKE_CASE_					:				Optional[int]=16    ,	SCREAMING_SNAKE_CASE_					:				Tuple=2    ,	SCREAMING_SNAKE_CASE_					:				Tuple=4    ,	SCREAMING_SNAKE_CASE_					:				Any=4    ,	SCREAMING_SNAKE_CASE_					:				str="gelu"    ,	SCREAMING_SNAKE_CASE_					:				Tuple=0.1    ,	SCREAMING_SNAKE_CASE_					:				int=0.1    ,	SCREAMING_SNAKE_CASE_					:				Union[str, Any]=[1, 2, 3, 4, 5]    ,	SCREAMING_SNAKE_CASE_					:				List[str]=25    ,	SCREAMING_SNAKE_CASE_					:				Dict=5    ,	):
        __lowerCamelCase:				Optional[int]     =	d_model
        __lowerCamelCase:				Dict     =	parent
        __lowerCamelCase:				List[Any]     =	batch_size
        __lowerCamelCase:				Dict     =	prediction_length
        __lowerCamelCase:				List[Any]     =	context_length
        __lowerCamelCase:				Union[str, Any]     =	cardinality
        __lowerCamelCase:				int     =	num_time_features
        __lowerCamelCase:				Optional[Any]     =	lags_sequence
        __lowerCamelCase:				Optional[Any]     =	embedding_dimension
        __lowerCamelCase:				Any     =	is_training
        __lowerCamelCase:				Dict     =	hidden_size
        __lowerCamelCase:				List[Any]     =	num_hidden_layers
        __lowerCamelCase:				List[str]     =	num_attention_heads
        __lowerCamelCase:				Optional[int]     =	intermediate_size
        __lowerCamelCase:				Optional[Any]     =	hidden_act
        __lowerCamelCase:				Optional[int]     =	hidden_dropout_prob
        __lowerCamelCase:				Any     =	attention_probs_dropout_prob

        __lowerCamelCase:				List[str]     =	context_length
        __lowerCamelCase:				Any     =	prediction_length + label_length
        __lowerCamelCase:				List[str]     =	label_length

        __lowerCamelCase:				str     =	moving_average
        __lowerCamelCase:				List[str]     =	autocorrelation_factor





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[str]							):
        return AutoformerConfig(
            d_model=self.d_model    ,	encoder_layers=self.num_hidden_layers    ,	decoder_layers=self.num_hidden_layers    ,	encoder_attention_heads=self.num_attention_heads    ,	decoder_attention_heads=self.num_attention_heads    ,	encoder_ffn_dim=self.intermediate_size    ,	decoder_ffn_dim=self.intermediate_size    ,	dropout=self.hidden_dropout_prob    ,	attention_dropout=self.attention_probs_dropout_prob    ,	prediction_length=self.prediction_length    ,	context_length=self.context_length    ,	label_length=self.label_length    ,	lags_sequence=self.lags_sequence    ,	num_time_features=self.num_time_features    ,	num_static_categorical_features=1    ,	cardinality=[self.cardinality]    ,	embedding_dimension=[self.embedding_dimension]    ,	moving_average=self.moving_average    ,	)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Dict    ,	SCREAMING_SNAKE_CASE_					:				str							):
        __lowerCamelCase:				int     =	config.context_length + max(config.lags_sequence							)

        __lowerCamelCase:				Any     =	ids_tensor([self.batch_size, 1]    ,	config.cardinality[0]							)
        __lowerCamelCase:				List[str]     =	floats_tensor([self.batch_size, _past_length, config.num_time_features]							)
        __lowerCamelCase:				int     =	floats_tensor([self.batch_size, _past_length]							)
        __lowerCamelCase:				Optional[int]     =	floats_tensor([self.batch_size, _past_length]							) > 0.5

        # decoder inputs
        __lowerCamelCase:				Optional[Any]     =	floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]							)
        __lowerCamelCase:				Optional[int]     =	floats_tensor([self.batch_size, config.prediction_length]							)

        __lowerCamelCase:				str     =	{
            '''past_values''': past_values,
            '''static_categorical_features''': static_categorical_features,
            '''past_time_features''': past_time_features,
            '''past_observed_mask''': past_observed_mask,
            '''future_time_features''': future_time_features,
            '''future_values''': future_values,
        }
        return inputs_dict





     def  SCREAMING_SNAKE_CASE__       (    self					:				Optional[Any]							):
        __lowerCamelCase:				Tuple     =	self.get_config()
        __lowerCamelCase:				Tuple     =	self.prepare_autoformer_inputs_dict(UpperCamelCase__							)
        return config, inputs_dict





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[Any]							):
        __lowerCamelCase:				Tuple     =	self.prepare_config_and_inputs()
        return config, inputs_dict







     def  SCREAMING_SNAKE_CASE__       (    self					:				List[str]    ,	SCREAMING_SNAKE_CASE_					:				Any    ,	SCREAMING_SNAKE_CASE_					:				Optional[int]							):
        __lowerCamelCase:				Optional[int]     =	AutoformerModel(config=UpperCamelCase__							).to(UpperCamelCase__							).eval()
        __lowerCamelCase:				List[str]     =	model(**UpperCamelCase__							)

        __lowerCamelCase:				Any     =	outputs.encoder_last_hidden_state
        __lowerCamelCase:				str     =	outputs.last_hidden_state

        with tempfile.TemporaryDirectory() as tmpdirname:
           __lowerCamelCase:				Tuple     =	model.get_encoder()
           encoder.save_pretrained(UpperCamelCase__							)
           __lowerCamelCase:				Union[str, Any]     =	AutoformerEncoder.from_pretrained(UpperCamelCase__							).to(UpperCamelCase__							)

        __lowerCamelCase:				str     =	model.create_network_inputs(**UpperCamelCase__							)
        __lowerCamelCase:				Dict     =	model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]							)

        __lowerCamelCase:				Tuple     =	torch.cat(
            (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])    ,	dim=-1    ,	)
        __lowerCamelCase:				List[Any]     =	encoder(inputs_embeds=UpperCamelCase__							)[0]
        self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3							)

        __lowerCamelCase:				Dict     =	(
            torch.mean(transformer_inputs[:, : config.context_length, ...]    ,	dim=1							)
            .unsqueeze(1							)
            .repeat(1    ,	config.prediction_length    ,	1							)
        )
        __lowerCamelCase:				Optional[Any]     =	torch.zeros(
            [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]    ,	device=enc_input.device    ,	)

        __lowerCamelCase:				Tuple     =	torch.cat(
            (
                torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)    ,	dim=1							),
                feature[:, config.context_length - config.label_length :, ...],
            )    ,	dim=-1    ,	)
        __lowerCamelCase:				str     =	torch.cat(
            (
                torch.cat((trend_input[:, -config.label_length :, ...], mean)    ,	dim=1							),
                feature[:, config.context_length - config.label_length :, ...],
            )    ,	dim=-1    ,	)

        with tempfile.TemporaryDirectory() as tmpdirname:
           __lowerCamelCase:				str     =	model.get_decoder()
           decoder.save_pretrained(UpperCamelCase__							)
           __lowerCamelCase:				str     =	AutoformerDecoder.from_pretrained(UpperCamelCase__							).to(UpperCamelCase__							)

        __lowerCamelCase:				Any     =	decoder(
            trend=UpperCamelCase__    ,	inputs_embeds=UpperCamelCase__    ,	encoder_hidden_states=UpperCamelCase__    ,	)[0]

        self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1E-3							)







@require_torch
class        a					(			SCREAMING_SNAKE_CASE_     ,SCREAMING_SNAKE_CASE_     ,unittest.TestCase   ):
     UpperCAmelCase__ :  Dict						      =	(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
     UpperCAmelCase__ :  str						      =	(AutoformerForPrediction,) if is_torch_available() else ()
     UpperCAmelCase__ :  List[Any]						      =	{"feature-extraction": AutoformerModel} if is_torch_available() else {}
     UpperCAmelCase__ :  Dict						      =	False
     UpperCAmelCase__ :  int						      =	False
     UpperCAmelCase__ :  Any						      =	False
     UpperCAmelCase__ :  Optional[int]						      =	False
     UpperCAmelCase__ :  List[str]						      =	False
     UpperCAmelCase__ :  Union[str, Any]						      =	False





     def  SCREAMING_SNAKE_CASE__       (    self					:				int							):
        __lowerCamelCase:				List[str]     =	AutoformerModelTester(self							)
        __lowerCamelCase:				Dict     =	ConfigTester(self    ,	config_class=UpperCamelCase__    ,	has_text_modality=UpperCamelCase__							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[str]							):
        self.config_tester.run_common_tests()





     def  SCREAMING_SNAKE_CASE__       (    self					:				str							):
        __lowerCamelCase:				Dict     =	self.model_tester.prepare_config_and_inputs()
        for model_class in self.all_model_classes:
           __lowerCamelCase:				int     =	model_class(UpperCamelCase__							)

           with tempfile.TemporaryDirectory() as tmpdirname:
              model.save_pretrained(UpperCamelCase__							)
              __lowerCamelCase:				int     =	model_class.from_pretrained(UpperCamelCase__    ,	output_loading_info=UpperCamelCase__							)
           self.assertEqual(info["""missing_keys"""]    ,	[]							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        __lowerCamelCase:				List[Any]     =	self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_encoder_decoder_model_standalone(*UpperCamelCase__							)





     @unittest.skip(reason="""Model has no tokens embeddings"""							)
     def  SCREAMING_SNAKE_CASE__       (    self					:				List[Any]							):
        pass





     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        __lowerCamelCase:				Optional[Any]     =	inspect.signature(getattr(UpperCamelCase__    ,	"""forward"""							)							)
        # The main input is the name of the argument after `self`
        __lowerCamelCase:				Tuple     =	list(model_signature.parameters.keys()							)[1]
        self.assertEqual(AutoformerModel.main_input_name    ,	UpperCamelCase__							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        __lowerCamelCase:				Any     =	self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           __lowerCamelCase:				str     =	model_class(UpperCamelCase__							)
           __lowerCamelCase:				Tuple     =	inspect.signature(model.forward							)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           __lowerCamelCase:				List[str]     =	[*signature.parameters.keys()]

           __lowerCamelCase:				int     =	[
               '''past_values''',
               '''past_time_features''',
               '''past_observed_mask''',
               '''static_categorical_features''',
               '''static_real_features''',
               '''future_values''',
               '''future_time_features''',
           ]

           if model.__class__.__name__ in ["AutoformerForPrediction"]:
              expected_arg_names.append("""future_observed_mask"""							)

           expected_arg_names.extend(
               [
                   """decoder_attention_mask""",
                   """head_mask""",
                   """decoder_head_mask""",
                   """cross_attn_head_mask""",
                   """encoder_outputs""",
                   """past_key_values""",
                   """output_hidden_states""",
                   """output_attentions""",
                   """use_cache""",
                   """return_dict""",
               ]							)

           self.assertListEqual(arg_names[: len(UpperCamelCase__							)]    ,	UpperCamelCase__							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Optional[int]							):
        __lowerCamelCase:				Dict     =	self.model_tester.prepare_config_and_inputs_for_common()
        __lowerCamelCase:				Dict     =	True

        __lowerCamelCase:				int     =	getattr(self.model_tester    ,	"""seq_length"""    ,	UpperCamelCase__							)
        __lowerCamelCase:				Union[str, Any]     =	getattr(self.model_tester    ,	"""decoder_seq_length"""    ,	UpperCamelCase__							)
        __lowerCamelCase:				Tuple     =	getattr(self.model_tester    ,	"""encoder_seq_length"""    ,	UpperCamelCase__							)
        __lowerCamelCase:				Dict     =	getattr(self.model_tester    ,	"""d_model"""    ,	UpperCamelCase__							)
        __lowerCamelCase:				Dict     =	getattr(self.model_tester    ,	"""num_attention_heads"""    ,	UpperCamelCase__							)
        __lowerCamelCase:				Union[str, Any]     =	d_model // num_attention_heads

        for model_class in self.all_model_classes:
           __lowerCamelCase:				List[Any]     =	True
           __lowerCamelCase:				Optional[int]     =	False
           __lowerCamelCase:				Union[str, Any]     =	True
           __lowerCamelCase:				Any     =	model_class(UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           with torch.no_grad():
              __lowerCamelCase:				List[str]     =	model(**self._prepare_for_class(UpperCamelCase__    ,	UpperCamelCase__							)							)
           __lowerCamelCase:				List[Any]     =	outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
           self.assertEqual(len(UpperCamelCase__							)    ,	self.model_tester.num_hidden_layers							)

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           __lowerCamelCase:				Dict     =	True
           __lowerCamelCase:				Tuple     =	model_class(UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           with torch.no_grad():
              __lowerCamelCase:				Tuple     =	model(**self._prepare_for_class(UpperCamelCase__    ,	UpperCamelCase__							)							)
           __lowerCamelCase:				Any     =	outputs.encoder_attentions
           self.assertEqual(len(UpperCamelCase__							)    ,	self.model_tester.num_hidden_layers							)

           self.assertListEqual(
               list(attentions[0].shape[-3:]							)    ,	[self.model_tester.num_attention_heads, encoder_seq_length, dim]    ,	)
           __lowerCamelCase:				Union[str, Any]     =	len(UpperCamelCase__							)

           __lowerCamelCase:				List[Any]     =	7

           if "last_hidden_state" in outputs:
              correct_outlen += 1

           if "trend" in outputs:
              correct_outlen += 1

           if "past_key_values" in outputs:
              correct_outlen += 1  # past_key_values have been returned

           if "loss" in outputs:
              correct_outlen += 1

           if "params" in outputs:
              correct_outlen += 1

           self.assertEqual(UpperCamelCase__    ,	UpperCamelCase__							)

           # decoder attentions
           __lowerCamelCase:				str     =	outputs.decoder_attentions
           self.assertIsInstance(UpperCamelCase__    ,	(list, tuple)							)
           self.assertEqual(len(UpperCamelCase__							)    ,	self.model_tester.num_hidden_layers							)
           self.assertListEqual(
               list(decoder_attentions[0].shape[-3:]							)    ,	[self.model_tester.num_attention_heads, decoder_seq_length, dim]    ,	)

           # cross attentions
           __lowerCamelCase:				Optional[Any]     =	outputs.cross_attentions
           self.assertIsInstance(UpperCamelCase__    ,	(list, tuple)							)
           self.assertEqual(len(UpperCamelCase__							)    ,	self.model_tester.num_hidden_layers							)
           self.assertListEqual(
               list(cross_attentions[0].shape[-3:]							)    ,	[self.model_tester.num_attention_heads, decoder_seq_length, dim]    ,	)

        # Check attention is always last and order is fine
        __lowerCamelCase:				Optional[int]     =	True
        __lowerCamelCase:				Optional[int]     =	True
        __lowerCamelCase:				Tuple     =	model_class(UpperCamelCase__							)
        model.to(UpperCamelCase__							)
        model.eval()
        with torch.no_grad():
           __lowerCamelCase:				Dict     =	model(**self._prepare_for_class(UpperCamelCase__    ,	UpperCamelCase__							)							)

        self.assertEqual(out_len + 2    ,	len(UpperCamelCase__							)							)

        __lowerCamelCase:				Optional[int]     =	outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

        self.assertEqual(len(UpperCamelCase__							)    ,	self.model_tester.num_hidden_layers							)
        self.assertListEqual(
            list(self_attentions[0].shape[-3:]							)    ,	[self.model_tester.num_attention_heads, encoder_seq_length, dim]    ,	)







     @is_flaky()
     def  SCREAMING_SNAKE_CASE__       (    self					:				Optional[int]							):
        super().test_retain_grad_hidden_states_attentions()



def     __lowerCAmelCase						(							snake_case	:    Union[str, Any]="train-batch.pt" )       ->							str:
   __lowerCamelCase:				Dict     =	hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""						,      filename=__UpperCamelCase						,      repo_type="""dataset""" )
   __lowerCamelCase:				Tuple     =	torch.load(__UpperCamelCase						,      map_location=__UpperCamelCase )
   return batch







@require_torch
@slow
class        a					(			unittest.TestCase   ):





     def  SCREAMING_SNAKE_CASE__       (    self					:				Union[str, Any]							):
        __lowerCamelCase:				Dict     =	AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(UpperCamelCase__							)
        __lowerCamelCase:				int     =	prepare_batch()

        with torch.no_grad():
           __lowerCamelCase:				Any     =	model(
               past_values=batch["""past_values"""]    ,	past_time_features=batch["""past_time_features"""]    ,	past_observed_mask=batch["""past_observed_mask"""]    ,	static_categorical_features=batch["""static_categorical_features"""]    ,	future_values=batch["""future_values"""]    ,	future_time_features=batch["""future_time_features"""]    ,	)[0]

        __lowerCamelCase:				Any     =	torch.Size(
            (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)							)
        self.assertEqual(output.shape    ,	UpperCamelCase__							)

        __lowerCamelCase:				Any     =	torch.tensor(
            [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]    ,	device=UpperCamelCase__							)
        self.assertTrue(torch.allclose(output[0, :3, :3]    ,	UpperCamelCase__    ,	atol=UpperCamelCase__							)							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				str							):
        __lowerCamelCase:				Tuple     =	AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(UpperCamelCase__							)
        __lowerCamelCase:				Optional[Any]     =	prepare_batch("""val-batch.pt"""							)
        with torch.no_grad():
           __lowerCamelCase:				int     =	model(
               past_values=batch["""past_values"""]    ,	past_time_features=batch["""past_time_features"""]    ,	past_observed_mask=batch["""past_observed_mask"""]    ,	static_categorical_features=batch["""static_categorical_features"""]    ,	).encoder_last_hidden_state
        __lowerCamelCase:				Tuple     =	torch.Size((64, model.config.context_length, model.config.d_model)							)
        self.assertEqual(output.shape    ,	UpperCamelCase__							)

        __lowerCamelCase:				Dict     =	torch.tensor(
            [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]    ,	device=UpperCamelCase__							)
        self.assertTrue(torch.allclose(output[0, :3, :3]    ,	UpperCamelCase__    ,	atol=UpperCamelCase__							)							)







     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        __lowerCamelCase:				int     =	AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(UpperCamelCase__							)
        __lowerCamelCase:				int     =	prepare_batch("""val-batch.pt"""							)
        with torch.no_grad():
           __lowerCamelCase:				Optional[int]     =	model.generate(
               static_categorical_features=batch["""static_categorical_features"""]    ,	past_time_features=batch["""past_time_features"""]    ,	past_values=batch["""past_values"""]    ,	future_time_features=batch["""future_time_features"""]    ,	past_observed_mask=batch["""past_observed_mask"""]    ,	)
        __lowerCamelCase:				Tuple     =	torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)							)
        self.assertEqual(outputs.sequences.shape    ,	UpperCamelCase__							)

        __lowerCamelCase:				str     =	torch.tensor([3130.6763, 4056.5293, 7053.0786]    ,	device=UpperCamelCase__							)
        __lowerCamelCase:				List[str]     =	outputs.sequences.mean(dim=1							)
        self.assertTrue(torch.allclose(mean_prediction[0, -3:]    ,	UpperCamelCase__    ,	rtol=1E-1							)							)






import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin



class        a					(			_UpperCAmelCase   ):
     UpperCAmelCase__ :  Dict						      =	"Speech2TextFeatureExtractor"
     UpperCAmelCase__ :  str						      =	"Speech2TextTokenizer"





     def __init__(    self					:				Optional[Any]    ,	SCREAMING_SNAKE_CASE_					:				List[str]    ,	SCREAMING_SNAKE_CASE_					:				Optional[int]							):
        super().__init__(SCREAMING_SNAKE_CASE_    ,	SCREAMING_SNAKE_CASE_							)
        __lowerCamelCase:				Any     =	self.feature_extractor
        __lowerCamelCase:				List[Any]     =	False





     def __call__(    self					:				List[str]    ,	*SCREAMING_SNAKE_CASE_					:				Union[str, Any]    ,	**SCREAMING_SNAKE_CASE_					:				List[Any]							):
        # For backward compatibility
        if self._in_target_context_manager:
           return self.current_processor(*SCREAMING_SNAKE_CASE_    ,	**SCREAMING_SNAKE_CASE_							)

        if "raw_speech" in kwargs:
           warnings.warn("""Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."""							)
           __lowerCamelCase:				Dict     =	kwargs.pop("""raw_speech"""							)
        else:
           __lowerCamelCase:				int     =	kwargs.pop("""audio"""    ,	SCREAMING_SNAKE_CASE_							)
        __lowerCamelCase:				Dict     =	kwargs.pop("""sampling_rate"""    ,	SCREAMING_SNAKE_CASE_							)
        __lowerCamelCase:				int     =	kwargs.pop("""text"""    ,	SCREAMING_SNAKE_CASE_							)
        if len(SCREAMING_SNAKE_CASE_							) > 0:
           __lowerCamelCase:				Dict     =	args[0]
           __lowerCamelCase:				Optional[Any]     =	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:
           __lowerCamelCase:				List[str]     =	self.feature_extractor(SCREAMING_SNAKE_CASE_    ,	*SCREAMING_SNAKE_CASE_    ,	sampling_rate=SCREAMING_SNAKE_CASE_    ,	**SCREAMING_SNAKE_CASE_							)
        if text is not None:
           __lowerCamelCase:				Any     =	self.tokenizer(SCREAMING_SNAKE_CASE_    ,	**SCREAMING_SNAKE_CASE_							)

        if text is None:
           return inputs
        elif audio is None:
           return encodings
        else:
           __lowerCamelCase:				List[Any]     =	encodings["""input_ids"""]
           return inputs





     def  SCREAMING_SNAKE_CASE__       (    self					:				List[str]    ,	*SCREAMING_SNAKE_CASE_					:				Optional[Any]    ,	**SCREAMING_SNAKE_CASE_					:				str							):
        return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE_    ,	**SCREAMING_SNAKE_CASE_							)





     def  SCREAMING_SNAKE_CASE__       (    self					:				Tuple    ,	*SCREAMING_SNAKE_CASE_					:				Any    ,	**SCREAMING_SNAKE_CASE_					:				List[Any]							):
        return self.tokenizer.decode(*SCREAMING_SNAKE_CASE_    ,	**SCREAMING_SNAKE_CASE_							)







     @contextmanager
     def  SCREAMING_SNAKE_CASE__       (    self					:				Any							):
        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."""							)
        __lowerCamelCase:				Any     =	True
        __lowerCamelCase:				Any     =	self.tokenizer
        yield
        __lowerCamelCase:				Any     =	self.feature_extractor
        __lowerCamelCase:				Optional[Any]     =	False


