


'''simple docstring'''

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 _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						int      )  ->			List[str]:
			__magic_name__	:   Optional[int]					     =					'| <pad> <unk> <s> </s> a b c d e f g h i j k'.split()
			__magic_name__	:   Any					     =					dict(zip(_A  ,					range(len(_A      )      )      )      )

			__magic_name__	:   str					     =					{
			    'unk_token': '<unk>',
			    'bos_token': '<s>',
			    'eos_token': '</s>',
			}
			__magic_name__	:   int					     =					{
			    'feature_size': 1,
			    'padding_value': 0.0,
			    'sampling_rate': 16000,
			    'return_attention_mask': False,
			    'do_normalize': True,
			}

			__magic_name__	:   str					     =					tempfile.mkdtemp()
			__magic_name__	:   Union[str, Any]					     =					os.path.join(self.tmpdirname  ,					VOCAB_FILES_NAMES['vocab_file']      )
			__magic_name__	:   List[Any]					     =					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
			__magic_name__	:   int					     =					'hf-internal-testing/ngram-beam-search-decoder'







		def        __lowerCAmelCase		( self		:						Union[str, Any]  ,					**_A		:						int      )  ->			Tuple:
			__magic_name__	:   str					     =					self.add_kwargs_tokens_map.copy()
			kwargs.update(_A      )
			return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname  ,					**_A      )







		def        __lowerCAmelCase		( self		:						Optional[int]  ,					**_A		:						Optional[int]      )  ->			Optional[int]:
			return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname  ,					**_A      )







		def        __lowerCAmelCase		( self		:						Optional[int]  ,					**_A		:						List[str]      )  ->			Optional[Any]:
			return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name  ,					**_A      )







		def        __lowerCAmelCase		( self		:						Dict      )  ->			Optional[Any]:
			shutil.rmtree(self.tmpdirname      )







		def        __lowerCAmelCase		( self		:						List[Any]      )  ->			Union[str, Any]:
			__magic_name__	:   str					     =					self.get_tokenizer()
			__magic_name__	:   Any					     =					self.get_feature_extractor()
			__magic_name__	:   List[str]					     =					self.get_decoder()

			__magic_name__	:   Optional[Any]					     =					WavaVecaProcessorWithLM(tokenizer=_A  ,					feature_extractor=_A  ,					decoder=_A      )

			processor.save_pretrained(self.tmpdirname      )
			__magic_name__	:   Union[str, Any]					     =					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        __lowerCAmelCase		( self		:						List[str]      )  ->			Dict:
			__magic_name__	:   Optional[int]					     =					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
			__magic_name__	:   Tuple					     =					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        __lowerCAmelCase		( self		:						List[Any]      )  ->			Dict:
			__magic_name__	:   Tuple					     =					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        __lowerCAmelCase		( self		:						Any      )  ->			Tuple:
			__magic_name__	:   Any					     =					self.get_feature_extractor()
			__magic_name__	:   List[Any]					     =					self.get_tokenizer()
			__magic_name__	:   int					     =					self.get_decoder()

			__magic_name__	:   str					     =					WavaVecaProcessorWithLM(tokenizer=_A  ,					feature_extractor=_A  ,					decoder=_A      )

			__magic_name__	:   int					     =					floats_list((3, 1000)      )

			__magic_name__	:   Tuple					     =					feature_extractor(_A  ,					return_tensors='np'      )
			__magic_name__	:   Union[str, Any]					     =					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        __lowerCAmelCase		( self		:						int      )  ->			Tuple:
			__magic_name__	:   Dict					     =					self.get_feature_extractor()
			__magic_name__	:   Optional[int]					     =					self.get_tokenizer()
			__magic_name__	:   Union[str, Any]					     =					self.get_decoder()

			__magic_name__	:   int					     =					WavaVecaProcessorWithLM(tokenizer=_A  ,					feature_extractor=_A  ,					decoder=_A      )

			__magic_name__	:   Optional[int]					     =					'This is a test string'

			__magic_name__	:   Any					     =					processor(text=_A      )

			__magic_name__	:   Union[str, Any]					     =					tokenizer(_A      )

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







		def        __lowerCAmelCase		( self		:						List[str]  ,					_A		:						Tuple=(2, 10, 16)  ,					_A		:						int=77      )  ->			Optional[Any]:
			np.random.seed(_A      )
			return np.random.rand(*_A      )







		def        __lowerCAmelCase		( self		:						Dict      )  ->			Optional[Any]:
			__magic_name__	:   Union[str, Any]					     =					self.get_feature_extractor()
			__magic_name__	:   Tuple					     =					self.get_tokenizer()
			__magic_name__	:   int					     =					self.get_decoder()

			__magic_name__	:   Any					     =					WavaVecaProcessorWithLM(tokenizer=_A  ,					feature_extractor=_A  ,					decoder=_A      )

			__magic_name__	:   int					     =					self._get_dummy_logits(shape=(10, 16)  ,					seed=13      )

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

			__magic_name__	:   Optional[Any]					     =					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        __lowerCAmelCase		( self		:						Union[str, Any]  ,					_A		:						Optional[Any]      )  ->			List[str]:
			__magic_name__	:   List[Any]					     =					self.get_feature_extractor()
			__magic_name__	:   List[str]					     =					self.get_tokenizer()
			__magic_name__	:   List[str]					     =					self.get_decoder()

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

			__magic_name__	:   List[Any]					     =					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:
				__magic_name__	:   Any					     =					processor.batch_decode(_A      )
			else:
				with get_context(_A      ).Pool() as pool:
					__magic_name__	:   Optional[int]					     =					processor.batch_decode(_A  ,					_A      )

			__magic_name__	:   Union[str, Any]					     =					list(_A      )

			with get_context('fork'      ).Pool() as p:
				__magic_name__	:   List[str]					     =					decoder.decode_beams_batch(_A  ,					_A      )

			__magic_name__     ,    __magic_name__     ,    __magic_name__	:   Tuple					     =					[], [], []
			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        __lowerCAmelCase		( self		:						Dict      )  ->			Optional[Any]:
			__magic_name__	:   Tuple					     =					self.get_feature_extractor()
			__magic_name__	:   Optional[Any]					     =					self.get_tokenizer()
			__magic_name__	:   Optional[Any]					     =					self.get_decoder()

			__magic_name__	:   Dict					     =					WavaVecaProcessorWithLM(tokenizer=_A  ,					feature_extractor=_A  ,					decoder=_A      )

			__magic_name__	:   Tuple					     =					self._get_dummy_logits()

			__magic_name__	:   Any					     =					15
			__magic_name__	:   Any					     =					-20.0
			__magic_name__	:   Union[str, Any]					     =					-4.0

			__magic_name__	:   Optional[int]					     =					processor.batch_decode(
			    _A  ,					beam_width=_A  ,					beam_prune_logp=_A  ,					token_min_logp=_A  ,					)
			__magic_name__	:   List[Any]					     =					decoded_processor_out.text

			__magic_name__	:   Tuple					     =					list(_A      )

			with get_context('fork'      ).Pool() as pool:
				__magic_name__	:   str					     =					decoder.decode_beams_batch(
				    _A  ,					_A  ,					beam_width=_A  ,					beam_prune_logp=_A  ,					token_min_logp=_A  ,					)

			__magic_name__	:   Union[str, Any]					     =					[d[0][0] for d in decoded_decoder_out]
			__magic_name__	:   Optional[int]					     =					[d[0][2] for d in decoded_decoder_out]
			__magic_name__	:   List[Any]					     =					[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        __lowerCAmelCase		( self		:						Tuple      )  ->			Tuple:
			__magic_name__	:   Any					     =					self.get_feature_extractor()
			__magic_name__	:   Tuple					     =					self.get_tokenizer()
			__magic_name__	:   Union[str, Any]					     =					self.get_decoder()

			__magic_name__	:   str					     =					WavaVecaProcessorWithLM(tokenizer=_A  ,					feature_extractor=_A  ,					decoder=_A      )

			__magic_name__	:   Any					     =					self._get_dummy_logits()

			__magic_name__	:   List[Any]					     =					2.0
			__magic_name__	:   str					     =					5.0
			__magic_name__	:   Tuple					     =					-20.0
			__magic_name__	:   List[Any]					     =					True

			__magic_name__	:   List[Any]					     =					processor.batch_decode(
			    _A  ,					alpha=_A  ,					beta=_A  ,					unk_score_offset=_A  ,					lm_score_boundary=_A  ,					)
			__magic_name__	:   Optional[Any]					     =					decoded_processor_out.text

			__magic_name__	:   Tuple					     =					list(_A      )
			decoder.reset_params(
			    alpha=_A  ,					beta=_A  ,					unk_score_offset=_A  ,					lm_score_boundary=_A  ,					)

			with get_context('fork'      ).Pool() as pool:
				__magic_name__	:   List[Any]					     =					decoder.decode_beams_batch(
				    _A  ,					_A  ,					)

			__magic_name__	:   List[Any]					     =					[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      )
			__magic_name__	:   int					     =					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        __lowerCAmelCase		( self		:						Tuple      )  ->			Any:
			__magic_name__	:   str					     =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )

			__magic_name__	:   Tuple					     =					processor.decoder.model_container[processor.decoder._model_key]
			__magic_name__	:   str					     =					Path(language_model._kenlm_model.path.decode('utf-8'      )      ).parent.parent.absolute()

			__magic_name__	:   Union[str, Any]					     =					os.listdir(_A      )
			__magic_name__	:   Optional[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        __lowerCAmelCase		( self		:						int      )  ->			List[Any]:
			__magic_name__	:   str					     =					snapshot_download('hf-internal-testing/processor_with_lm'      )

			__magic_name__	:   List[str]					     =					WavaVecaProcessorWithLM.from_pretrained(_A      )

			__magic_name__	:   List[Any]					     =					processor.decoder.model_container[processor.decoder._model_key]
			__magic_name__	:   List[str]					     =					Path(language_model._kenlm_model.path.decode('utf-8'      )      ).parent.parent.absolute()

			__magic_name__	:   Optional[Any]					     =					os.listdir(_A      )
			__magic_name__	:   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        __lowerCAmelCase		( self		:						Dict      )  ->			Optional[Any]:
			__magic_name__	:   List[Any]					     =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
			__magic_name__	:   Any					     =					AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'      )

			__magic_name__	:   Union[str, Any]					     =					floats_list((3, 1000)      )

			__magic_name__	:   Dict					     =					processor_wavaveca(_A  ,					return_tensors='np'      )
			__magic_name__	:   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      )

			__magic_name__	:   Dict					     =					self._get_dummy_logits()

			__magic_name__	:   Optional[int]					     =					processor_wavaveca.batch_decode(_A      )
			__magic_name__	:   Dict					     =					processor_auto.batch_decode(_A      )

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







		def        __lowerCAmelCase		( self		:						int      )  ->			Any:
			__magic_name__	:   Union[str, Any]					     =					self.get_feature_extractor()
			__magic_name__	:   int					     =					self.get_tokenizer()
			__magic_name__	:   Tuple					     =					self.get_decoder()

			__magic_name__	:   Optional[int]					     =					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        __lowerCAmelCase		( _A		:						List[Any]  ,					_A		:						str      )  ->			Dict:
			__magic_name__	:   Optional[Any]					     =					[d[key] for d in offsets]
			return retrieved_list







		def        __lowerCAmelCase		( self		:						List[str]      )  ->			Any:
			__magic_name__	:   Tuple					     =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
			__magic_name__	:   List[Any]					     =					self._get_dummy_logits()[0]

			__magic_name__	:   Optional[Any]					     =					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        __lowerCAmelCase		( self		:						int      )  ->			Any:
			__magic_name__	:   int					     =					WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
			__magic_name__	:   str					     =					self._get_dummy_logits()

			__magic_name__	:   Union[str, Any]					     =					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        __lowerCAmelCase		( self		:						Optional[Any]      )  ->			Optional[Any]:
			import torch

			__magic_name__	:   List[Any]					     =					load_dataset('common_voice'  ,					'en'  ,					split='train'  ,					streaming=_A      )
			__magic_name__	:   List[Any]					     =					ds.cast_column('audio'  ,					datasets.Audio(sampling_rate=16000      )      )
			__magic_name__	:   Tuple					     =					iter(_A      )
			__magic_name__	:   Dict					     =					next(_A      )

			__magic_name__	:   Optional[Any]					     =					AutoProcessor.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm'      )
			__magic_name__	:   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
			__magic_name__	:   Any					     =					processor(sample['audio']['array']  ,					return_tensors='pt'      ).input_values

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

			__magic_name__	:   Union[str, Any]					     =					processor.decode(logits[0]  ,					output_word_offsets=_A      )

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

			__magic_name__	:   List[Any]					     =					'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
			__magic_name__	:   int					     =					torch.tensor(self.get_from_offsets(_A  ,					'start_time'      )      )
			__magic_name__	:   List[Any]					     =					torch.tensor(self.get_from_offsets(_A  ,					'end_time'      )      )

			# fmt: off
			__magic_name__	:   Optional[int]					     =					torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599]      )
			__magic_name__	:   Any					     =					torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94]      )
			# fmt: on

			self.assertTrue(torch.allclose(_A  ,					_A  ,					atol=0.01      )      )
			self.assertTrue(torch.allclose(_A  ,					_A  ,					atol=0.01      )      )



'''simple docstring'''

# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
lowerCAmelCase				:Optional[int]        =      abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)





def lowerCamelCase      (      lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	config.addinivalue_line(
	    'markers'		,		'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'		)
	config.addinivalue_line(
	    'markers'		,		'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'		)
	config.addinivalue_line('markers'		,		'is_pipeline_test: mark test to run only when pipelines are tested'		)
	config.addinivalue_line('markers'		,		'is_staging_test: mark test to run only in the staging environment'		)
	config.addinivalue_line('markers'		,		'accelerate_tests: mark test that require accelerate'		)
	config.addinivalue_line('markers'		,		'tool_tests: mark the tool tests that are run on their specific schedule'		)





def lowerCamelCase      (      lowerCAmelCase    :     Any		):





	"""simple docstring"""







	from transformers.testing_utils import pytest_addoption_shared

	pytest_addoption_shared(lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     Dict		):





	"""simple docstring"""







	from transformers.testing_utils import pytest_terminal_summary_main

	__magic_name__	:   Tuple					     =					terminalreporter.config.getoption('--make-reports'		)
	if make_reports:
		pytest_terminal_summary_main(lowerCAmelCase		,		id=lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     List[Any]		,		lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	if exitstatus == 5:
		__magic_name__	:   Any					     =					0


# Doctest custom flag to ignore output.
lowerCAmelCase				:List[str]        =      doctest.register_optionflag('''IGNORE_RESULT''')

lowerCAmelCase				:Union[str, Any]        =      doctest.OutputChecker
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						List[str]  ,					_A		:						Tuple  ,					_A		:						Tuple  ,					_A		:						str      )  ->			int:
			if IGNORE_RESULT & optionflags:
				return True
			return OutputChecker.check_output(self  ,					_A  ,					_A  ,					_A      )







lowerCAmelCase				:Optional[Any]        =      CustomOutputChecker
lowerCAmelCase				:int        =      HfDoctestModule





lowerCAmelCase				:Any        =      HfDocTestParser