



import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
			from transformers import (
			    FlaxBertModel,
			    FlaxCLIPVisionModel,
			    FlaxVisionTextDualEncoderModel,
			    FlaxViTModel,
			    VisionTextDualEncoderConfig,
			    VisionTextDualEncoderProcessor,
			)
			from transformers.modeling_flax_pytorch_utils import (
			    convert_pytorch_state_dict_to_flax,
			    load_flax_weights_in_pytorch_model,
			)


if is_torch_available():
			import torch

			from transformers import VisionTextDualEncoderModel

if is_vision_available():
			from PIL import Image






def      __lowercase       (			a__       )    ->			Dict:
							if isinstance(UpperCAmelCase__							,       collections.abc.Iterable       ):
														return x
							return (x, x)

@require_flax
class        UpperCAmelCase_  :

						'''simple docstring'''




						def 	_A     (   self				,							_A				,							_A		):







													'''simple docstring'''

													pass






						def 	_A     (   self		):







													'''simple docstring'''

													pass






						def 	_A     (   self		):







													'''simple docstring'''

													pass






						def 	_A     (   self				,							_A				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= np.abs((a - b)		).max()
													self.assertLessEqual(UpperCamelCase__				,							UpperCamelCase__				,							f"""Difference between torch and flax is {diff} (>= {tol})."""		)






						def 	_A     (   self				,							_A				,							_A				,							_A				,							_A				,							_A=None				,							**_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__				,							UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel(UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= model(input_ids=UpperCamelCase__				,							pixel_values=UpperCamelCase__				,							attention_mask=UpperCamelCase__		)

													self.assertEqual(output['text_embeds'].shape				,							(input_ids.shape[0], config.projection_dim)		)
													self.assertEqual(output['image_embeds'].shape				,							(pixel_values.shape[0], config.projection_dim)		)






						def 	_A     (   self				,							_A				,							_A				,							_A				,							_A				,							_A=None				,							**_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= self.get_vision_text_model(UpperCamelCase__				,							UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= {'vision_model': vision_model, 'text_model': text_model}
													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= model(input_ids=UpperCamelCase__				,							pixel_values=UpperCamelCase__				,							attention_mask=UpperCamelCase__		)

													self.assertEqual(output['text_embeds'].shape				,							(input_ids.shape[0], model.config.projection_dim)		)
													self.assertEqual(output['image_embeds'].shape				,							(pixel_values.shape[0], model.config.projection_dim)		)






						def 	_A     (   self				,							_A				,							_A				,							_A				,							_A				,							_A=None				,							**_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= self.get_vision_text_model(UpperCamelCase__				,							UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= {'vision_model': vision_model, 'text_model': text_model}
													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= model(input_ids=UpperCamelCase__				,							pixel_values=UpperCamelCase__				,							attention_mask=UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= output[0]

													with tempfile.TemporaryDirectory() as tmpdirname:
																				model.save_pretrained(UpperCamelCase__		)
																				__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__		)

																				__SCREAMING_SNAKE_CASE									= model(input_ids=UpperCamelCase__				,							pixel_values=UpperCamelCase__				,							attention_mask=UpperCamelCase__		)
																				__SCREAMING_SNAKE_CASE									= after_output[0]
																				__SCREAMING_SNAKE_CASE									= np.amax(np.abs(out_a - out_a		)		)
																				self.assertLessEqual(UpperCamelCase__				,							1e-3		)






						def 	_A     (   self				,							_A				,							_A				,							_A				,							_A				,							_A=None				,							**_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= self.get_vision_text_model(UpperCamelCase__				,							UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= {'vision_model': vision_model, 'text_model': text_model}
													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= model(
													    input_ids=UpperCamelCase__				,							pixel_values=UpperCamelCase__				,							attention_mask=UpperCamelCase__				,							output_attentions=UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= output.vision_model_output.attentions
													self.assertEqual(len(UpperCamelCase__		)				,							vision_config.num_hidden_layers		)

													# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
													__SCREAMING_SNAKE_CASE									= to_atuple(vision_model.config.image_size		)
													__SCREAMING_SNAKE_CASE									= to_atuple(vision_model.config.patch_size		)
													__SCREAMING_SNAKE_CASE									= (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
													__SCREAMING_SNAKE_CASE									= num_patches + 1
													self.assertEqual(vision_attentions[0].shape[-3:]				,							(vision_config.num_attention_heads, seq_len, seq_len)		)

													__SCREAMING_SNAKE_CASE									= output.text_model_output.attentions
													self.assertEqual(len(UpperCamelCase__		)				,							text_config.num_hidden_layers		)

													self.assertEqual(
													    text_attentions[0].shape[-3:]				,							(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])				,							)






						def 	_A     (   self				,							_A				,							_A				,							_A		):







													'''simple docstring'''

													pt_model.to(UpperCamelCase__		)
													pt_model.eval()

													# prepare inputs
													__SCREAMING_SNAKE_CASE									= inputs_dict
													__SCREAMING_SNAKE_CASE									= {k: torch.tensor(v.tolist()		) for k, v in flax_inputs.items()}

													with torch.no_grad():
																				__SCREAMING_SNAKE_CASE									= pt_model(**UpperCamelCase__		).to_tuple()

													__SCREAMING_SNAKE_CASE									= fx_model(**UpperCamelCase__		).to_tuple()
													self.assertEqual(len(UpperCamelCase__		)				,							len(UpperCamelCase__		)				,							'Output lengths differ between Flax and PyTorch'		)
													for fx_output, pt_output in zip(fx_outputs[:4]				,							pt_outputs[:4]		):
																				self.assert_almost_equals(UpperCamelCase__				,							pt_output.numpy()				,							4e-2		)

													# PT -> Flax
													with tempfile.TemporaryDirectory() as tmpdirname:
																				pt_model.save_pretrained(UpperCamelCase__		)
																				__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__				,							from_pt=UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= fx_model_loaded(**UpperCamelCase__		).to_tuple()
													self.assertEqual(len(UpperCamelCase__		)				,							len(UpperCamelCase__		)				,							'Output lengths differ between Flax and PyTorch'		)
													for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]				,							pt_outputs[:4]		):
																				self.assert_almost_equals(UpperCamelCase__				,							pt_output.numpy()				,							4e-2		)

													# Flax -> PT
													with tempfile.TemporaryDirectory() as tmpdirname:
																				fx_model.save_pretrained(UpperCamelCase__		)
																				__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderModel.from_pretrained(UpperCamelCase__				,							from_flax=UpperCamelCase__		)

													pt_model_loaded.to(UpperCamelCase__		)
													pt_model_loaded.eval()

													with torch.no_grad():
																				__SCREAMING_SNAKE_CASE									= pt_model_loaded(**UpperCamelCase__		).to_tuple()

													self.assertEqual(len(UpperCamelCase__		)				,							len(UpperCamelCase__		)				,							'Output lengths differ between Flax and PyTorch'		)
													for fx_output, pt_output_loaded in zip(fx_outputs[:4]				,							pt_outputs_loaded[:4]		):
																				self.assert_almost_equals(UpperCamelCase__				,							pt_output_loaded.numpy()				,							4e-2		)






						def 	_A     (   self				,							_A				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__				,							UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderModel(UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel(UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= convert_pytorch_state_dict_to_flax(pt_model.state_dict()				,							UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= fx_state

													self.check_pt_flax_equivalence(UpperCamelCase__				,							UpperCamelCase__				,							UpperCamelCase__		)






						def 	_A     (   self				,							_A				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__				,							UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderModel(UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel(UpperCamelCase__		)

													__SCREAMING_SNAKE_CASE									= load_flax_weights_in_pytorch_model(UpperCamelCase__				,							fx_model.params		)

													self.check_pt_flax_equivalence(UpperCamelCase__				,							UpperCamelCase__				,							UpperCamelCase__		)






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.prepare_config_and_inputs()
													self.check_model_from_pretrained_configs(**UpperCamelCase__		)






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.prepare_config_and_inputs()
													self.check_vision_text_dual_encoder_from_pretrained(**UpperCamelCase__		)






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.prepare_config_and_inputs()
													self.check_save_load(**UpperCamelCase__		)






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.prepare_config_and_inputs()
													self.check_vision_text_output_attention(**UpperCamelCase__		)






						@is_pt_flax_cross_test
						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= self.prepare_config_and_inputs()
													__SCREAMING_SNAKE_CASE									= config_inputs_dict.pop('vision_config'		)
													__SCREAMING_SNAKE_CASE									= config_inputs_dict.pop('text_config'		)

													__SCREAMING_SNAKE_CASE									= config_inputs_dict

													self.check_equivalence_pt_to_flax(UpperCamelCase__				,							UpperCamelCase__				,							UpperCamelCase__		)
													self.check_equivalence_flax_to_pt(UpperCamelCase__				,							UpperCamelCase__				,							UpperCamelCase__		)






						@slow
						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= self.get_pretrained_model_and_inputs()

													__SCREAMING_SNAKE_CASE									= model_a(**UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= outputs[0]

													with tempfile.TemporaryDirectory() as tmp_dirname:
																				model_a.save_pretrained(UpperCamelCase__		)
																				__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__		)

																				__SCREAMING_SNAKE_CASE									= model_a(**UpperCamelCase__		)
																				__SCREAMING_SNAKE_CASE									= after_outputs[0]
																				__SCREAMING_SNAKE_CASE									= np.amax(np.abs(out_a - out_a		)		)
																				self.assertLessEqual(UpperCamelCase__				,							1e-5		)







@require_flax
class        UpperCAmelCase_  (       _snake_case   ,   unittest.TestCase	):

						'''simple docstring'''




						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
													    'hf-internal-testing/tiny-random-vit'				,							'hf-internal-testing/tiny-bert'				,							vision_from_pt=UpperCamelCase__				,							text_from_pt=UpperCamelCase__				,							)
													__SCREAMING_SNAKE_CASE									= 13
													__SCREAMING_SNAKE_CASE									= floats_tensor(
													    [
													        batch_size,
													        model.config.vision_config.num_channels,
													        model.config.vision_config.image_size,
													        model.config.vision_config.image_size,
													    ]		)
													__SCREAMING_SNAKE_CASE									= ids_tensor([batch_size, 4]				,							model.config.text_config.vocab_size		)
													__SCREAMING_SNAKE_CASE									= random_attention_mask([batch_size, 4]		)
													__SCREAMING_SNAKE_CASE									= {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

													return model, inputs






						def 	_A     (   self				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxViTModel(UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= FlaxBertModel(UpperCamelCase__		)
													return vision_model, text_model






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxViTModelTester(self		)
													__SCREAMING_SNAKE_CASE									= FlaxBertModelTester(self		)
													__SCREAMING_SNAKE_CASE									= vit_model_tester.prepare_config_and_inputs()
													__SCREAMING_SNAKE_CASE									= bert_model_tester.prepare_config_and_inputs()

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= vision_config_and_inputs

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= text_config_and_inputs

													# make sure that cross attention layers are added
													return {
													    "text_config": text_config,
													    "vision_config": vision_config,
													    "pixel_values": pixel_values,
													    "attention_mask": attention_mask,
													    "input_ids": input_ids,
													    "token_type_ids": token_type_ids,
													}







@require_torch
class        UpperCAmelCase_  (       _snake_case   ,   unittest.TestCase	):

						'''simple docstring'''




						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
													    'hf-internal-testing/tiny-random-clip'				,							'hf-internal-testing/tiny-bert'				,							vision_from_pt=UpperCamelCase__				,							text_from_pt=UpperCamelCase__				,							)
													__SCREAMING_SNAKE_CASE									= 13
													__SCREAMING_SNAKE_CASE									= floats_tensor(
													    [
													        batch_size,
													        model.config.vision_config.num_channels,
													        model.config.vision_config.image_size,
													        model.config.vision_config.image_size,
													    ]		)
													__SCREAMING_SNAKE_CASE									= ids_tensor([batch_size, 4]				,							model.config.text_config.vocab_size		)
													__SCREAMING_SNAKE_CASE									= random_attention_mask([batch_size, 4]		)
													__SCREAMING_SNAKE_CASE									= {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

													return model, inputs






						def 	_A     (   self				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxCLIPVisionModel(UpperCamelCase__		)
													__SCREAMING_SNAKE_CASE									= FlaxBertModel(UpperCamelCase__		)
													return vision_model, text_model






						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxCLIPVisionModelTester(self		)
													__SCREAMING_SNAKE_CASE									= FlaxBertModelTester(self		)
													__SCREAMING_SNAKE_CASE									= clip_model_tester.prepare_config_and_inputs()
													__SCREAMING_SNAKE_CASE									= bert_model_tester.prepare_config_and_inputs()

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= vision_config_and_inputs

													__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE									= text_config_and_inputs

													# make sure that cross attention layers are added
													return {
													    "text_config": text_config,
													    "vision_config": vision_config,
													    "pixel_values": pixel_values,
													    "attention_mask": attention_mask,
													    "input_ids": input_ids,
													    "token_type_ids": token_type_ids,
													}







@require_flax
@require_vision
class        UpperCAmelCase_  (       unittest.TestCase	):

						'''simple docstring'''




						@slow
						def 	_A     (   self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian'				,							logit_scale_init_value=1.0		)
													__SCREAMING_SNAKE_CASE									= VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'		)

													__SCREAMING_SNAKE_CASE									= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
													__SCREAMING_SNAKE_CASE									= processor(
													    text=['una foto di un gatto', 'una foto di un cane']				,							images=UpperCamelCase__				,							padding=UpperCamelCase__				,							return_tensors='np'		)

													__SCREAMING_SNAKE_CASE									= model(**UpperCamelCase__		)

													# verify the logits
													self.assertEqual(outputs.logits_per_image.shape				,							(inputs.pixel_values.shape[0], inputs.input_ids.shape[0])		)
													self.assertEqual(
													    outputs.logits_per_text.shape				,							(inputs.input_ids.shape[0], inputs.pixel_values.shape[0])				,							)

													__SCREAMING_SNAKE_CASE									= np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]		)

													self.assertTrue(np.allclose(outputs.logits_per_image				,							UpperCamelCase__				,							atol=1e-3		)		)










import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer

class        UpperCAmelCase_  (       UpperCamelCase_	):

						'''simple docstring'''




						UpperCamelCase__      :			Union[str, Any]      =  '''Wav2Vec2FeatureExtractor'''
						UpperCamelCase__      :			Union[str, Any]      =  '''AutoTokenizer'''






						def __init__(   self				,							_A				,							_A		):







													'''simple docstring'''

													super().__init__(_A				,							_A		)
													__SCREAMING_SNAKE_CASE									= self.feature_extractor
													__SCREAMING_SNAKE_CASE									= False






						@classmethod
						def 	_A     (   cls				,							_A				,							**_A		):







													'''simple docstring'''

													try:
																				return super().from_pretrained(_A				,							**_A		)
													except OSError:
																				warnings.warn(
																				    f"""Loading a tokenizer inside {cls.__name__} from a config that does not"""
																				    ' include a `tokenizer_class` attribute is deprecated and will be '
																				    'removed in v5. Please add `\'tokenizer_class\': \'Wav2Vec2CTCTokenizer\'`'
																				    ' attribute to either your `config.json` or `tokenizer_config.json` '
																				    'file to suppress this warning: '				,							_A				,							)

																				__SCREAMING_SNAKE_CASE									= WavaVecaFeatureExtractor.from_pretrained(_A				,							**_A		)
																				__SCREAMING_SNAKE_CASE									= WavaVecaCTCTokenizer.from_pretrained(_A				,							**_A		)

																				return cls(feature_extractor=_A				,							tokenizer=_A		)






						def __call__(   self				,							*_A				,							**_A		):







													'''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				,							*_A				,							**_A		):







													'''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				,							*_A				,							**_A		):







													'''simple docstring'''

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






						def 	_A     (   self				,							*_A				,							**_A		):







													'''simple docstring'''

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






						@contextmanager
						def 	_A     (   self		):







													'''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






