

import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
				from huggingface_hub import snapshot_download
				from pyctcdecode import BeamSearchDecoderCTC

				from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
				from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
				from transformers import WavaVecaForCTC



@require_pyctcdecode
class    _a						(unittest.TestCase    ):


					'''simple docstring'''






					def   __A      (			self      ):
						A__							:   str					       =		"""| <pad> <unk> <s> </s> a b c d e f g h i j k""".split()
						A__							:   int					       =		dict(zip(A__   ,	range(len(A__      )      )      )      )

						A__							:   str					       =		{
						    """unk_token""": """<unk>""",
						    """bos_token""": """<s>""",
						    """eos_token""": """</s>""",
						}
						A__							:   str					       =		{
						    """feature_size""": 1,
						    """padding_value""": 0.0,
						    """sampling_rate""": 1_6000,
						    """return_attention_mask""": False,
						    """do_normalize""": True,
						}

						A__							:   Optional[Any]					       =		tempfile.mkdtemp()
						A__							:   List[str]					       =		os.path.join(self.tmpdirname   ,	VOCAB_FILES_NAMES["""vocab_file"""]      )
						A__							:   List[str]					       =		os.path.join(self.tmpdirname   ,	A__      )
						with open(self.vocab_file   ,	"""w"""   ,	encoding="""utf-8"""      ) as fp:
							fp.write(json.dumps(A__      ) + """\n"""      )

						with open(self.feature_extraction_file   ,	"""w"""   ,	encoding="""utf-8"""      ) as fp:
							fp.write(json.dumps(A__      ) + """\n"""      )

						# load decoder from hub
						A__							:   Union[str, Any]					       =		"""hf-internal-testing/ngram-beam-search-decoder"""






					def   __A      (			self   ,	**A__      ):
						A__							:   int					       =		self.add_kwargs_tokens_map.copy()
						kwargs.update(A__      )
						return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname   ,	**A__      )






					def   __A      (			self   ,	**A__      ):
						return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname   ,	**A__      )






					def   __A      (			self   ,	**A__      ):
						return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name   ,	**A__      )






					def   __A      (			self      ):
						shutil.rmtree(self.tmpdirname      )






					def   __A      (			self      ):
						A__							:   Any					       =		self.get_tokenizer()
						A__							:   Tuple					       =		self.get_feature_extractor()
						A__							:   Tuple					       =		self.get_decoder()

						A__							:   List[Any]					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						processor.save_pretrained(self.tmpdirname      )
						A__							:   int					       =		WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname      )

						# tokenizer
						self.assertEqual(processor.tokenizer.get_vocab()   ,	tokenizer.get_vocab()      )
						self.assertIsInstance(processor.tokenizer   ,	A__      )

						# feature extractor
						self.assertEqual(processor.feature_extractor.to_json_string()   ,	feature_extractor.to_json_string()      )
						self.assertIsInstance(processor.feature_extractor   ,	A__      )

						# decoder
						self.assertEqual(processor.decoder._alphabet.labels   ,	decoder._alphabet.labels      )
						self.assertEqual(
						    processor.decoder.model_container[decoder._model_key]._unigram_set   ,	decoder.model_container[decoder._model_key]._unigram_set   ,	)
						self.assertIsInstance(processor.decoder   ,	A__      )






					def   __A      (			self      ):
						A__							:   Union[str, Any]					       =		WavaVecaProcessorWithLM(
						    tokenizer=self.get_tokenizer()   ,	feature_extractor=self.get_feature_extractor()   ,	decoder=self.get_decoder()      )
						processor.save_pretrained(self.tmpdirname      )

						# make sure that error is thrown when decoder alphabet doesn't match
						A__							:   str					       =		WavaVecaProcessorWithLM.from_pretrained(
						    self.tmpdirname   ,	alpha=5.0   ,	beta=3.0   ,	score_boundary=-7.0   ,	unk_score_offset=3      )

						# decoder
						self.assertEqual(processor.language_model.alpha   ,	5.0      )
						self.assertEqual(processor.language_model.beta   ,	3.0      )
						self.assertEqual(processor.language_model.score_boundary   ,	-7.0      )
						self.assertEqual(processor.language_model.unk_score_offset   ,	3      )






					def   __A      (			self      ):
						A__							:   str					       =		self.get_tokenizer()
						# add token to trigger raise
						tokenizer.add_tokens(["""xx"""]      )
						with self.assertRaisesRegex(A__   ,	"""include"""      ):
							WavaVecaProcessorWithLM(
							    tokenizer=A__   ,	feature_extractor=self.get_feature_extractor()   ,	decoder=self.get_decoder()      )






					def   __A      (			self      ):
						A__							:   Any					       =		self.get_feature_extractor()
						A__							:   Tuple					       =		self.get_tokenizer()
						A__							:   int					       =		self.get_decoder()

						A__							:   Union[str, Any]					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						A__							:   str					       =		floats_list((3, 1000)      )

						A__							:   Optional[int]					       =		feature_extractor(A__   ,	return_tensors="""np"""      )
						A__							:   List[str]					       =		processor(A__   ,	return_tensors="""np"""      )

						for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()   ,	input_processor[key].sum()   ,	delta=1e-2      )






					def   __A      (			self      ):
						A__							:   Any					       =		self.get_feature_extractor()
						A__							:   Dict					       =		self.get_tokenizer()
						A__							:   str					       =		self.get_decoder()

						A__							:   List[Any]					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						A__							:   Optional[int]					       =		"""This is a test string"""

						A__							:   Optional[Any]					       =		processor(text=A__      )

						A__							:   Union[str, Any]					       =		tokenizer(A__      )

						for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]   ,	encoded_processor[key]      )






					def   __A      (			self   ,	A__=(2, 10, 16)   ,	A__=77      ):
						np.random.seed(A__      )
						return np.random.rand(*A__      )






					def   __A      (			self      ):
						A__							:   str					       =		self.get_feature_extractor()
						A__							:   Any					       =		self.get_tokenizer()
						A__							:   str					       =		self.get_decoder()

						A__							:   Tuple					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						A__							:   Dict					       =		self._get_dummy_logits(shape=(10, 16)   ,	seed=13      )

						A__							:   Union[str, Any]					       =		processor.decode(A__      )

						A__							:   List[str]					       =		decoder.decode_beams(A__      )[0]

						self.assertEqual(decoded_decoder[0]   ,	decoded_processor.text      )
						self.assertEqual("""</s> <s> </s>"""   ,	decoded_processor.text      )
						self.assertEqual(decoded_decoder[-2]   ,	decoded_processor.logit_score      )
						self.assertEqual(decoded_decoder[-1]   ,	decoded_processor.lm_score      )






					@parameterized.expand([[None], ["""fork"""], ["""spawn"""]]      )
					def   __A      (			self   ,	A__      ):
						A__							:   Optional[Any]					       =		self.get_feature_extractor()
						A__							:   Dict					       =		self.get_tokenizer()
						A__							:   Optional[Any]					       =		self.get_decoder()

						A__							:   Optional[int]					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						A__							:   Tuple					       =		self._get_dummy_logits()

						# note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
						#       otherwise, the LM won't be available to the pool's sub-processes.
						# manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
						if pool_context is None:
							A__							:   Optional[int]					       =		processor.batch_decode(A__      )
						else:
							with get_context(A__      ).Pool() as pool:
								A__							:   Any					       =		processor.batch_decode(A__   ,	A__      )

						A__							:   Union[str, Any]					       =		list(A__      )

						with get_context("""fork"""      ).Pool() as p:
							A__							:   str					       =		decoder.decode_beams_batch(A__   ,	A__      )

						A__							:   Union[str, Any]					       =		[], [], []
						for beams in decoded_beams:
							texts_decoder.append(beams[0][0]      )
							logit_scores_decoder.append(beams[0][-2]      )
							lm_scores_decoder.append(beams[0][-1]      )

						self.assertListEqual(A__   ,	decoded_processor.text      )
						self.assertListEqual(["""<s> <s> </s>""", """<s> <s> <s>"""]   ,	decoded_processor.text      )
						self.assertListEqual(A__   ,	decoded_processor.logit_score      )
						self.assertListEqual(A__   ,	decoded_processor.lm_score      )






					def   __A      (			self      ):
						A__							:   Union[str, Any]					       =		self.get_feature_extractor()
						A__							:   str					       =		self.get_tokenizer()
						A__							:   Union[str, Any]					       =		self.get_decoder()

						A__							:   List[str]					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						A__							:   Any					       =		self._get_dummy_logits()

						A__							:   Optional[int]					       =		15
						A__							:   Dict					       =		-20.0
						A__							:   List[str]					       =		-4.0

						A__							:   Dict					       =		processor.batch_decode(
						    A__   ,	beam_width=A__   ,	beam_prune_logp=A__   ,	token_min_logp=A__   ,	)
						A__							:   List[str]					       =		decoded_processor_out.text

						A__							:   Optional[int]					       =		list(A__      )

						with get_context("""fork"""      ).Pool() as pool:
							A__							:   Tuple					       =		decoder.decode_beams_batch(
							    A__   ,	A__   ,	beam_width=A__   ,	beam_prune_logp=A__   ,	token_min_logp=A__   ,	)

						A__							:   str					       =		[d[0][0] for d in decoded_decoder_out]
						A__							:   Optional[Any]					       =		[d[0][2] for d in decoded_decoder_out]
						A__							:   str					       =		[d[0][3] for d in decoded_decoder_out]

						self.assertListEqual(A__   ,	A__      )
						self.assertListEqual(["""</s> <s> <s>""", """<s> <s> <s>"""]   ,	A__      )

						self.assertTrue(np.array_equal(A__   ,	decoded_processor_out.logit_score      )      )
						self.assertTrue(np.allclose([-20.054, -18.447]   ,	A__   ,	atol=1e-3      )      )

						self.assertTrue(np.array_equal(A__   ,	decoded_processor_out.lm_score      )      )
						self.assertTrue(np.allclose([-15.554, -13.9474]   ,	A__   ,	atol=1e-3      )      )






					def   __A      (			self      ):
						A__							:   Dict					       =		self.get_feature_extractor()
						A__							:   List[Any]					       =		self.get_tokenizer()
						A__							:   Dict					       =		self.get_decoder()

						A__							:   Dict					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						A__							:   List[str]					       =		self._get_dummy_logits()

						A__							:   str					       =		2.0
						A__							:   Any					       =		5.0
						A__							:   Any					       =		-20.0
						A__							:   Dict					       =		True

						A__							:   Union[str, Any]					       =		processor.batch_decode(
						    A__   ,	alpha=A__   ,	beta=A__   ,	unk_score_offset=A__   ,	lm_score_boundary=A__   ,	)
						A__							:   Union[str, Any]					       =		decoded_processor_out.text

						A__							:   List[Any]					       =		list(A__      )
						decoder.reset_params(
						    alpha=A__   ,	beta=A__   ,	unk_score_offset=A__   ,	lm_score_boundary=A__   ,	)

						with get_context("""fork"""      ).Pool() as pool:
							A__							:   Dict					       =		decoder.decode_beams_batch(
							    A__   ,	A__   ,	)

						A__							:   int					       =		[d[0][0] for d in decoded_decoder_out]

						self.assertListEqual(A__   ,	A__      )
						self.assertListEqual(["""<s> </s> <s> </s> </s>""", """</s> </s> <s> </s> </s>"""]   ,	A__      )
						A__							:   Any					       =		processor.decoder.model_container[processor.decoder._model_key]
						self.assertEqual(lm_model.alpha   ,	2.0      )
						self.assertEqual(lm_model.beta   ,	5.0      )
						self.assertEqual(lm_model.unk_score_offset   ,	-20.0      )
						self.assertEqual(lm_model.score_boundary   ,	A__      )






					def   __A      (			self      ):
						A__							:   List[Any]					       =		WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )

						A__							:   Optional[int]					       =		processor.decoder.model_container[processor.decoder._model_key]
						A__							:   List[str]					       =		Path(language_model._kenlm_model.path.decode("""utf-8"""      )      ).parent.parent.absolute()

						A__							:   List[Any]					       =		os.listdir(A__      )
						A__							:   int					       =		["""alphabet.json""", """language_model"""]

						downloaded_decoder_files.sort()
						expected_decoder_files.sort()

						# test that only decoder relevant files from
						# https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
						# are downloaded and none of the rest (e.g. README.md, ...)
						self.assertListEqual(A__   ,	A__      )






					def   __A      (			self      ):
						A__							:   Optional[int]					       =		snapshot_download("""hf-internal-testing/processor_with_lm"""      )

						A__							:   str					       =		WavaVecaProcessorWithLM.from_pretrained(A__      )

						A__							:   int					       =		processor.decoder.model_container[processor.decoder._model_key]
						A__							:   Optional[Any]					       =		Path(language_model._kenlm_model.path.decode("""utf-8"""      )      ).parent.parent.absolute()

						A__							:   Optional[int]					       =		os.listdir(A__      )
						A__							:   Optional[Any]					       =		os.listdir(A__      )

						local_decoder_files.sort()
						expected_decoder_files.sort()

						# test that both decoder form hub and local files in cache are the same
						self.assertListEqual(A__   ,	A__      )






					def   __A      (			self      ):
						A__							:   Tuple					       =		WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )
						A__							:   Any					       =		AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm"""      )

						A__							:   List[Any]					       =		floats_list((3, 1000)      )

						A__							:   int					       =		processor_wavaveca(A__   ,	return_tensors="""np"""      )
						A__							:   Union[str, Any]					       =		processor_auto(A__   ,	return_tensors="""np"""      )

						for key in input_wavaveca.keys():
							self.assertAlmostEqual(input_wavaveca[key].sum()   ,	input_auto[key].sum()   ,	delta=1e-2      )

						A__							:   Optional[int]					       =		self._get_dummy_logits()

						A__							:   int					       =		processor_wavaveca.batch_decode(A__      )
						A__							:   Any					       =		processor_auto.batch_decode(A__      )

						self.assertListEqual(decoded_wavaveca.text   ,	decoded_auto.text      )






					def   __A      (			self      ):
						A__							:   List[Any]					       =		self.get_feature_extractor()
						A__							:   int					       =		self.get_tokenizer()
						A__							:   Optional[Any]					       =		self.get_decoder()

						A__							:   Tuple					       =		WavaVecaProcessorWithLM(tokenizer=A__   ,	feature_extractor=A__   ,	decoder=A__      )

						self.assertListEqual(
						    processor.model_input_names   ,	feature_extractor.model_input_names   ,	msg="""`processor` and `feature_extractor` model input names do not match"""   ,	)






					@staticmethod
					def   __A      (			A__   ,	A__      ):
						A__							:   Optional[int]					       =		[d[key] for d in offsets]
						return retrieved_list






					def   __A      (			self      ):
						A__							:   Dict					       =		WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )
						A__							:   int					       =		self._get_dummy_logits()[0]

						A__							:   Dict					       =		processor.decode(A__   ,	output_word_offsets=A__      )
						# check Wav2Vec2CTCTokenizerOutput keys for word
						self.assertEqual(len(outputs.keys()      )   ,	4      )
						self.assertTrue("""text""" in outputs      )
						self.assertTrue("""word_offsets""" in outputs      )
						self.assertTrue(isinstance(A__   ,	A__      )      )

						self.assertEqual(""" """.join(self.get_from_offsets(outputs["""word_offsets"""]   ,	"""word"""      )      )   ,	outputs.text      )
						self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]   ,	"""word"""      )   ,	["""<s>""", """<s>""", """</s>"""]      )
						self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]   ,	"""start_offset"""      )   ,	[0, 2, 4]      )
						self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]   ,	"""end_offset"""      )   ,	[1, 3, 5]      )






					def   __A      (			self      ):
						A__							:   str					       =		WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )
						A__							:   Optional[Any]					       =		self._get_dummy_logits()

						A__							:   Tuple					       =		processor.batch_decode(A__   ,	output_word_offsets=A__      )

						# check Wav2Vec2CTCTokenizerOutput keys for word
						self.assertEqual(len(outputs.keys()      )   ,	4      )
						self.assertTrue("""text""" in outputs      )
						self.assertTrue("""word_offsets""" in outputs      )
						self.assertTrue(isinstance(A__   ,	A__      )      )

						self.assertListEqual(
						    [""" """.join(self.get_from_offsets(A__   ,	"""word"""      )      ) for o in outputs["""word_offsets"""]]   ,	outputs.text      )
						self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]   ,	"""word"""      )   ,	["""<s>""", """<s>""", """</s>"""]      )
						self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]   ,	"""start_offset"""      )   ,	[0, 2, 4]      )
						self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]   ,	"""end_offset"""      )   ,	[1, 3, 5]      )






					@slow
					@require_torch
					@require_torchaudio
					def   __A      (			self      ):
						import torch

						A__							:   int					       =		load_dataset("""common_voice"""   ,	"""en"""   ,	split="""train"""   ,	streaming=A__      )
						A__							:   Optional[int]					       =		ds.cast_column("""audio"""   ,	datasets.Audio(sampling_rate=1_6000      )      )
						A__							:   Union[str, Any]					       =		iter(A__      )
						A__							:   Optional[Any]					       =		next(A__      )

						A__							:   Tuple					       =		AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm"""      )
						A__							:   Optional[Any]					       =		WavaVecaForCTC.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm"""      )

						# compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
						A__							:   List[Any]					       =		processor(sample["""audio"""]["""array"""]   ,	return_tensors="""pt"""      ).input_values

						with torch.no_grad():
							A__							:   Optional[int]					       =		model(A__      ).logits.cpu().numpy()

						A__							:   int					       =		processor.decode(logits[0]   ,	output_word_offsets=A__      )

						A__							:   int					       =		model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
						A__							:   List[Any]					       =		[
						    {
						        """start_time""": d["""start_offset"""] * time_offset,
						        """end_time""": d["""end_offset"""] * time_offset,
						        """word""": d["""word"""],
						    }
						    for d in output["""word_offsets"""]
						]

						A__							:   List[str]					       =		"""WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL"""

						# output words
						self.assertEqual(""" """.join(self.get_from_offsets(A__   ,	"""word"""      )      )   ,	A__      )
						self.assertEqual(""" """.join(self.get_from_offsets(A__   ,	"""word"""      )      )   ,	output.text      )

						# output times
						A__							:   Tuple					       =		torch.tensor(self.get_from_offsets(A__   ,	"""start_time"""      )      )
						A__							:   Optional[Any]					       =		torch.tensor(self.get_from_offsets(A__   ,	"""end_time"""      )      )

						# fmt: off
						A__							:   Union[str, Any]					       =		torch.tensor([1.4_1_9_9, 1.6_5_9_9, 2.2_5_9_9, 3.0, 3.2_4, 3.5_9_9_9, 3.7_9_9_9, 4.0_9_9_9, 4.2_6, 4.9_4, 5.2_8, 5.6_5_9_9, 5.7_8, 5.9_4, 6.3_2, 6.5_3_9_9, 6.6_5_9_9]      )
						A__							:   Dict					       =		torch.tensor([1.5_3_9_9, 1.8_9_9_9, 2.9, 3.1_6, 3.5_3_9_9, 3.7_2, 4.0_1_9_9, 4.1_7_9_9, 4.7_6, 5.1_5_9_9, 5.5_5_9_9, 5.6_9_9_9, 5.8_6, 6.1_9_9_9, 6.3_8, 6.6_1_9_9, 6.9_4]      )
						# fmt: on

						self.assertTrue(torch.allclose(A__   ,	A__   ,	atol=0.0_1      )      )
						self.assertTrue(torch.allclose(A__   ,	A__   ,	atol=0.0_1      )      )






import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin



class    _a						(__magic_name__    ):


					'''simple docstring'''






					UpperCAmelCase__:       Optional[Any]  							=	'''MCTCTFeatureExtractor'''
					UpperCAmelCase__:       Optional[int]  							=	'''AutoTokenizer'''






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






					def __call__(			self   ,	*A__   ,	**A__      ):
						# For backward compatibility
						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."""      )
							A__							:   Dict					       =		kwargs.pop("""raw_speech"""      )
						else:
							A__							:   Tuple					       =		kwargs.pop("""audio"""   ,	A__      )
						A__							:   Union[str, Any]					       =		kwargs.pop("""sampling_rate"""   ,	A__      )
						A__							:   int					       =		kwargs.pop("""text"""   ,	A__      )
						if len(A__      ) > 0:
							A__							:   Optional[int]					       =		args[0]
							A__							:   Dict					       =		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:
							A__							:   List[str]					       =		self.feature_extractor(A__   ,	*A__   ,	sampling_rate=A__   ,	**A__      )
						if text is not None:
							A__							:   Optional[Any]					       =		self.tokenizer(A__   ,	**A__      )

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






					def   __A      (			self   ,	*A__   ,	**A__      ):
						return self.tokenizer.batch_decode(*A__   ,	**A__      )






					def   __A      (			self   ,	*A__   ,	**A__      ):
						# For backward compatibility
						if self._in_target_context_manager:
							return self.current_processor.pad(*A__   ,	**A__      )

						A__							:   Optional[Any]					       =		kwargs.pop("""input_features"""   ,	A__      )
						A__							:   Union[str, Any]					       =		kwargs.pop("""labels"""   ,	A__      )
						if len(A__      ) > 0:
							A__							:   List[Any]					       =		args[0]
							A__							:   Optional[int]					       =		args[1:]

						if input_features is not None:
							A__							:   Union[str, Any]					       =		self.feature_extractor.pad(A__   ,	*A__   ,	**A__      )
						if labels is not None:
							A__							:   List[Any]					       =		self.tokenizer.pad(A__   ,	**A__      )

						if labels is None:
							return input_features
						elif input_features is None:
							return labels
						else:
							A__							:   Dict					       =		labels["""input_ids"""]
							return input_features






					def   __A      (			self   ,	*A__   ,	**A__      ):
						return self.tokenizer.decode(*A__   ,	**A__      )






					@contextmanager
					def   __A      (			self      ):
						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."""      )
						A__							:   int					       =		True
						A__							:   List[Any]					       =		self.tokenizer
						yield
						A__							:   Tuple					       =		self.feature_extractor
						A__							:   Dict					       =		False



