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




   def 			__a		(					self    :       List[str]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split()
     SCREAMING_SNAKE_CASE__    							=   dict(zip(_lowercase ,			range(len(_lowercase   )   )   )   )

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

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

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

     # load decoder from hub
     SCREAMING_SNAKE_CASE__    							=   """hf-internal-testing/ngram-beam-search-decoder"""




   def 			__a		(					self    :       Optional[Any] ,			**_lowercase    :       Dict   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.add_kwargs_tokens_map.copy()
     kwargs.update(_lowercase   )
     return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname ,			**_lowercase   )




   def 			__a		(					self    :       int ,			**_lowercase    :       str   ):



     """simple docstring"""






     return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname ,			**_lowercase   )




   def 			__a		(					self    :       Optional[Any] ,			**_lowercase    :       Optional[int]   ):



     """simple docstring"""






     return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name ,			**_lowercase   )




   def 			__a		(					self    :       List[str]   ):



     """simple docstring"""






     shutil.rmtree(self.tmpdirname   )




   def 			__a		(					self    :       Dict   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     processor.save_pretrained(self.tmpdirname   )
     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname   )

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

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

     # 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 ,			_lowercase   )




   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   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
     SCREAMING_SNAKE_CASE__    							=   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    :       Optional[Any]   ):



     """simple docstring"""






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




   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   floats_list((3, 10_00)   )

     SCREAMING_SNAKE_CASE__    							=   feature_extractor(_lowercase ,			return_tensors="""np"""   )
     SCREAMING_SNAKE_CASE__    							=   processor(_lowercase ,			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    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   """This is a test string"""

     SCREAMING_SNAKE_CASE__    							=   processor(text=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   tokenizer(_lowercase   )

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




   def 			__a		(					self    :       Optional[int] ,			_lowercase    :       Any=(2, 10, 16) ,			_lowercase    :       Union[str, Any]=77   ):



     """simple docstring"""






     np.random.seed(_lowercase   )
     return np.random.rand(*_lowercase   )




   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self._get_dummy_logits(shape=(10, 16) ,			seed=13   )

     SCREAMING_SNAKE_CASE__    							=   processor.decode(_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   decoder.decode_beams(_lowercase   )[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    :       Tuple ,			_lowercase    :       Optional[int]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   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:
       SCREAMING_SNAKE_CASE__    							=   processor.batch_decode(_lowercase   )
     else:
       with get_context(_lowercase   ).Pool() as pool:
         SCREAMING_SNAKE_CASE__    							=   processor.batch_decode(_lowercase ,			_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   list(_lowercase   )

     with get_context("""fork"""   ).Pool() as p:
       SCREAMING_SNAKE_CASE__    							=   decoder.decode_beams_batch(_lowercase ,			_lowercase   )

     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   [], [], []
     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(_lowercase ,			decoded_processor.text   )
     self.assertListEqual(["""<s> <s> </s>""", """<s> <s> <s>"""] ,			decoded_processor.text   )
     self.assertListEqual(_lowercase ,			decoded_processor.logit_score   )
     self.assertListEqual(_lowercase ,			decoded_processor.lm_score   )




   def 			__a		(					self    :       int   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self._get_dummy_logits()

     SCREAMING_SNAKE_CASE__    							=   15
     SCREAMING_SNAKE_CASE__    							=   -20.0
     SCREAMING_SNAKE_CASE__    							=   -4.0

     SCREAMING_SNAKE_CASE__    							=   processor.batch_decode(
         _lowercase ,			beam_width=_lowercase ,			beam_prune_logp=_lowercase ,			token_min_logp=_lowercase ,			)
     SCREAMING_SNAKE_CASE__    							=   decoded_processor_out.text

     SCREAMING_SNAKE_CASE__    							=   list(_lowercase   )

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

     SCREAMING_SNAKE_CASE__    							=   [d[0][0] for d in decoded_decoder_out]
     SCREAMING_SNAKE_CASE__    							=   [d[0][2] for d in decoded_decoder_out]
     SCREAMING_SNAKE_CASE__    							=   [d[0][3] for d in decoded_decoder_out]

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

     self.assertTrue(np.array_equal(_lowercase ,			decoded_processor_out.logit_score   )   )
     self.assertTrue(np.allclose([-20.0_54, -18.4_47] ,			_lowercase ,			atol=1E-3   )   )

     self.assertTrue(np.array_equal(_lowercase ,			decoded_processor_out.lm_score   )   )
     self.assertTrue(np.allclose([-15.5_54, -13.94_74] ,			_lowercase ,			atol=1E-3   )   )




   def 			__a		(					self    :       str   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self._get_dummy_logits()

     SCREAMING_SNAKE_CASE__    							=   2.0
     SCREAMING_SNAKE_CASE__    							=   5.0
     SCREAMING_SNAKE_CASE__    							=   -20.0
     SCREAMING_SNAKE_CASE__    							=   True

     SCREAMING_SNAKE_CASE__    							=   processor.batch_decode(
         _lowercase ,			alpha=_lowercase ,			beta=_lowercase ,			unk_score_offset=_lowercase ,			lm_score_boundary=_lowercase ,			)
     SCREAMING_SNAKE_CASE__    							=   decoded_processor_out.text

     SCREAMING_SNAKE_CASE__    							=   list(_lowercase   )
     decoder.reset_params(
         alpha=_lowercase ,			beta=_lowercase ,			unk_score_offset=_lowercase ,			lm_score_boundary=_lowercase ,			)

     with get_context("""fork"""   ).Pool() as pool:
       SCREAMING_SNAKE_CASE__    							=   decoder.decode_beams_batch(
           _lowercase ,			_lowercase ,			)

     SCREAMING_SNAKE_CASE__    							=   [d[0][0] for d in decoded_decoder_out]

     self.assertListEqual(_lowercase ,			_lowercase   )
     self.assertListEqual(["""<s> </s> <s> </s> </s>""", """</s> </s> <s> </s> </s>"""] ,			_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   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 ,			_lowercase   )




   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""   )

     SCREAMING_SNAKE_CASE__    							=   processor.decoder.model_container[processor.decoder._model_key]
     SCREAMING_SNAKE_CASE__    							=   Path(language_model._kenlm_model.path.decode("""utf-8"""   )   ).parent.parent.absolute()

     SCREAMING_SNAKE_CASE__    							=   os.listdir(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ["""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(_lowercase ,			_lowercase   )




   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   snapshot_download("""hf-internal-testing/processor_with_lm"""   )

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM.from_pretrained(_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   processor.decoder.model_container[processor.decoder._model_key]
     SCREAMING_SNAKE_CASE__    							=   Path(language_model._kenlm_model.path.decode("""utf-8"""   )   ).parent.parent.absolute()

     SCREAMING_SNAKE_CASE__    							=   os.listdir(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   os.listdir(_lowercase   )

     local_decoder_files.sort()
     expected_decoder_files.sort()

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




   def 			__a		(					self    :       int   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""   )
     SCREAMING_SNAKE_CASE__    							=   AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm"""   )

     SCREAMING_SNAKE_CASE__    							=   floats_list((3, 10_00)   )

     SCREAMING_SNAKE_CASE__    							=   processor_wavaveca(_lowercase ,			return_tensors="""np"""   )
     SCREAMING_SNAKE_CASE__    							=   processor_auto(_lowercase ,			return_tensors="""np"""   )

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

     SCREAMING_SNAKE_CASE__    							=   self._get_dummy_logits()

     SCREAMING_SNAKE_CASE__    							=   processor_wavaveca.batch_decode(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   processor_auto.batch_decode(_lowercase   )

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




   def 			__a		(					self    :       int   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_feature_extractor()
     SCREAMING_SNAKE_CASE__    							=   self.get_tokenizer()
     SCREAMING_SNAKE_CASE__    							=   self.get_decoder()

     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM(tokenizer=_lowercase ,			feature_extractor=_lowercase ,			decoder=_lowercase   )

     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		(					_lowercase    :       str ,			_lowercase    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   [d[key] for d in offsets]
     return retrieved_list




   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""   )
     SCREAMING_SNAKE_CASE__    							=   self._get_dummy_logits()[0]

     SCREAMING_SNAKE_CASE__    							=   processor.decode(_lowercase ,			output_word_offsets=_lowercase   )
     # 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(_lowercase ,			_lowercase   )   )

     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    :       Optional[int]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""   )
     SCREAMING_SNAKE_CASE__    							=   self._get_dummy_logits()

     SCREAMING_SNAKE_CASE__    							=   processor.batch_decode(_lowercase ,			output_word_offsets=_lowercase   )

     # 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(_lowercase ,			_lowercase   )   )

     self.assertListEqual(
         [""" """.join(self.get_from_offsets(_lowercase ,			"""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    :       Tuple   ):



     """simple docstring"""






     import torch

     SCREAMING_SNAKE_CASE__    							=   load_dataset("""common_voice""" ,			"""en""" ,			split="""train""" ,			streaming=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ds.cast_column("""audio""" ,			datasets.Audio(sampling_rate=1_60_00   )   )
     SCREAMING_SNAKE_CASE__    							=   iter(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   next(_lowercase   )

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

     with torch.no_grad():
       SCREAMING_SNAKE_CASE__    							=   model(_lowercase   ).logits.cpu().numpy()

     SCREAMING_SNAKE_CASE__    							=   processor.decode(logits[0] ,			output_word_offsets=_lowercase   )

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

     SCREAMING_SNAKE_CASE__    							=   """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(_lowercase ,			"""word"""   )   ) ,			_lowercase   )
     self.assertEqual(""" """.join(self.get_from_offsets(_lowercase ,			"""word"""   )   ) ,			output.text   )

     # output times
     SCREAMING_SNAKE_CASE__    							=   torch.tensor(self.get_from_offsets(_lowercase ,			"""start_time"""   )   )
     SCREAMING_SNAKE_CASE__    							=   torch.tensor(self.get_from_offsets(_lowercase ,			"""end_time"""   )   )

     # fmt: off
     SCREAMING_SNAKE_CASE__    							=   torch.tensor([1.41_99, 1.65_99, 2.25_99, 3.0, 3.24, 3.59_99, 3.79_99, 4.09_99, 4.26, 4.94, 5.28, 5.65_99, 5.78, 5.94, 6.32, 6.53_99, 6.65_99]   )
     SCREAMING_SNAKE_CASE__    							=   torch.tensor([1.53_99, 1.89_99, 2.9, 3.16, 3.53_99, 3.72, 4.01_99, 4.17_99, 4.76, 5.15_99, 5.55_99, 5.69_99, 5.86, 6.19_99, 6.38, 6.61_99, 6.94]   )
     # fmt: on

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

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase    :				List[Any]							     =	logging.get_logger(__name__)

__lowerCamelCase    :				str							     =	{
    '''facebook/timesformer''': '''https://huggingface.co/facebook/timesformer/resolve/main/config.json''',
}







class __snake_case       (		lowerCamelCase_	):
   lowerCAmelCase_														=							"timesformer"




   def __init__(					self    :       Any ,			_lowercase    :       Tuple=2_24 ,			_lowercase    :       Tuple=16 ,			_lowercase    :       List[Any]=3 ,			_lowercase    :       str=8 ,			_lowercase    :       Optional[Any]=7_68 ,			_lowercase    :       List[str]=12 ,			_lowercase    :       List[str]=12 ,			_lowercase    :       Dict=30_72 ,			_lowercase    :       List[str]="gelu" ,			_lowercase    :       List[str]=0.0 ,			_lowercase    :       List[str]=0.0 ,			_lowercase    :       Tuple=0.02 ,			_lowercase    :       List[Any]=1E-6 ,			_lowercase    :       List[str]=True ,			_lowercase    :       Dict="divided_space_time" ,			_lowercase    :       Union[str, Any]=0 ,			**_lowercase    :       Union[str, Any] ,			):



     """simple docstring"""






     super().__init__(**_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   image_size
     SCREAMING_SNAKE_CASE__    							=   patch_size
     SCREAMING_SNAKE_CASE__    							=   num_channels
     SCREAMING_SNAKE_CASE__    							=   num_frames

     SCREAMING_SNAKE_CASE__    							=   hidden_size
     SCREAMING_SNAKE_CASE__    							=   num_hidden_layers
     SCREAMING_SNAKE_CASE__    							=   num_attention_heads
     SCREAMING_SNAKE_CASE__    							=   intermediate_size
     SCREAMING_SNAKE_CASE__    							=   hidden_act
     SCREAMING_SNAKE_CASE__    							=   hidden_dropout_prob
     SCREAMING_SNAKE_CASE__    							=   attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE__    							=   initializer_range
     SCREAMING_SNAKE_CASE__    							=   layer_norm_eps
     SCREAMING_SNAKE_CASE__    							=   qkv_bias

     SCREAMING_SNAKE_CASE__    							=   attention_type
     SCREAMING_SNAKE_CASE__    							=   drop_path_rate
