






"""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  ):

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    '| <pad> <unk> <s> </s> a b c d e f g h i j k'.split()
       UpperCamelCase__         =    dict(zip(UpperCAmelCase_ ,				range(len(UpperCAmelCase_      )      )      )      )

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

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

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

       # load decoder from hub
       UpperCamelCase__         =    'hf-internal-testing/ngram-beam-search-decoder'

   def 						SCREAMING_SNAKE_CASE__ (					self ,				**snake_case_      )		->       int:
       UpperCamelCase__         =    self.add_kwargs_tokens_map.copy()
       kwargs.update(UpperCAmelCase_      )
       return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname ,				**UpperCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				**snake_case_      )		->       Union[str, Any]:
       return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname ,				**UpperCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				**snake_case_      )		->       List[str]:
       return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name ,				**UpperCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       shutil.rmtree(self.tmpdirname      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

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

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

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

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

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    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
       UpperCamelCase__         =    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 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    self.get_tokenizer()
       # add token to trigger raise
       tokenizer.add_tokens(['xx']      )
       with self.assertRaisesRegex(UpperCAmelCase_ ,				'include'      ):
           WavaVecaProcessorWithLM(
               tokenizer=UpperCAmelCase_ ,				feature_extractor=self.get_feature_extractor() ,				decoder=self.get_decoder()      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

       UpperCamelCase__         =    floats_list((3, 1000)      )

       UpperCamelCase__         =    feature_extractor(UpperCAmelCase_ ,				return_tensors='np'      )
       UpperCamelCase__         =    processor(UpperCAmelCase_ ,				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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

       UpperCamelCase__         =    'This is a test string'

       UpperCamelCase__         =    processor(text=UpperCAmelCase_      )

       UpperCamelCase__         =    tokenizer(UpperCAmelCase_      )

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_=(2, 10, 16) ,				snake_case_=77      )		->       int:
       np.random.seed(UpperCAmelCase_      )
       return np.random.rand(*UpperCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

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

       UpperCamelCase__         =    processor.decode(UpperCAmelCase_      )

       UpperCamelCase__         =    decoder.decode_beams(UpperCAmelCase_      )[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 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

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

       UpperCamelCase__         =    list(UpperCAmelCase_      )

       with get_context('fork'      ).Pool() as p:
           UpperCamelCase__         =    decoder.decode_beams_batch(UpperCAmelCase_ ,				UpperCAmelCase_      )

       UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__         =    [], [], []
       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(UpperCAmelCase_ ,				decoded_processor.text      )
       self.assertListEqual(['<s> <s> </s>', '<s> <s> <s>'] ,				decoded_processor.text      )
       self.assertListEqual(UpperCAmelCase_ ,				decoded_processor.logit_score      )
       self.assertListEqual(UpperCAmelCase_ ,				decoded_processor.lm_score      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

       UpperCamelCase__         =    self._get_dummy_logits()

       UpperCamelCase__         =    15
       UpperCamelCase__         =    -20.0
       UpperCamelCase__         =    -4.0

       UpperCamelCase__         =    processor.batch_decode(
           UpperCAmelCase_ ,				beam_width=UpperCAmelCase_ ,				beam_prune_logp=UpperCAmelCase_ ,				token_min_logp=UpperCAmelCase_ ,				)
       UpperCamelCase__         =    decoded_processor_out.text

       UpperCamelCase__         =    list(UpperCAmelCase_      )

       with get_context('fork'      ).Pool() as pool:
           UpperCamelCase__         =    decoder.decode_beams_batch(
               UpperCAmelCase_ ,				UpperCAmelCase_ ,				beam_width=UpperCAmelCase_ ,				beam_prune_logp=UpperCAmelCase_ ,				token_min_logp=UpperCAmelCase_ ,				)

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

       self.assertListEqual(UpperCAmelCase_ ,				UpperCAmelCase_      )
       self.assertListEqual(['</s> <s> <s>', '<s> <s> <s>'] ,				UpperCAmelCase_      )

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

       self.assertTrue(np.array_equal(UpperCAmelCase_ ,				decoded_processor_out.lm_score      )      )
       self.assertTrue(np.allclose([-15.554, -13.9_474] ,				UpperCAmelCase_ ,				atol=1E-3      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

       UpperCamelCase__         =    self._get_dummy_logits()

       UpperCamelCase__         =    2.0
       UpperCamelCase__         =    5.0
       UpperCamelCase__         =    -20.0
       UpperCamelCase__         =    True

       UpperCamelCase__         =    processor.batch_decode(
           UpperCAmelCase_ ,				alpha=UpperCAmelCase_ ,				beta=UpperCAmelCase_ ,				unk_score_offset=UpperCAmelCase_ ,				lm_score_boundary=UpperCAmelCase_ ,				)
       UpperCamelCase__         =    decoded_processor_out.text

       UpperCamelCase__         =    list(UpperCAmelCase_      )
       decoder.reset_params(
           alpha=UpperCAmelCase_ ,				beta=UpperCAmelCase_ ,				unk_score_offset=UpperCAmelCase_ ,				lm_score_boundary=UpperCAmelCase_ ,				)

       with get_context('fork'      ).Pool() as pool:
           UpperCamelCase__         =    decoder.decode_beams_batch(
               UpperCAmelCase_ ,				UpperCAmelCase_ ,				)

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

       self.assertListEqual(UpperCAmelCase_ ,				UpperCAmelCase_      )
       self.assertListEqual(['<s> </s> <s> </s> </s>', '</s> </s> <s> </s> </s>'] ,				UpperCAmelCase_      )
       UpperCamelCase__         =    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 ,				UpperCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )

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

       UpperCamelCase__         =    os.listdir(UpperCAmelCase_      )
       UpperCamelCase__         =    ['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(UpperCAmelCase_ ,				UpperCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    snapshot_download('hf-internal-testing/processor_with_lm'      )

       UpperCamelCase__         =    WavaVecaProcessorWithLM.from_pretrained(UpperCAmelCase_      )

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

       UpperCamelCase__         =    os.listdir(UpperCAmelCase_      )
       UpperCamelCase__         =    os.listdir(UpperCAmelCase_      )

       local_decoder_files.sort()
       expected_decoder_files.sort()

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

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__         =    WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
       UpperCamelCase__         =    AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'      )

       UpperCamelCase__         =    floats_list((3, 1000)      )

       UpperCamelCase__         =    processor_wavaveca(UpperCAmelCase_ ,				return_tensors='np'      )
       UpperCamelCase__         =    processor_auto(UpperCAmelCase_ ,				return_tensors='np'      )

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

       UpperCamelCase__         =    self._get_dummy_logits()

       UpperCamelCase__         =    processor_wavaveca.batch_decode(UpperCAmelCase_      )
       UpperCamelCase__         =    processor_auto.batch_decode(UpperCAmelCase_      )

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

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    self.get_feature_extractor()
       UpperCamelCase__         =    self.get_tokenizer()
       UpperCamelCase__         =    self.get_decoder()

       UpperCamelCase__         =    WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_ ,				feature_extractor=UpperCAmelCase_ ,				decoder=UpperCAmelCase_      )

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

   @staticmethod
   def 						SCREAMING_SNAKE_CASE__ (					snake_case_ ,				snake_case_      )		->       Union[str, Any]:
       UpperCamelCase__         =    [d[key] for d in offsets]
       return retrieved_list

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
       UpperCamelCase__         =    self._get_dummy_logits()[0]

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

       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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
       UpperCamelCase__         =    self._get_dummy_logits()

       UpperCamelCase__         =    processor.batch_decode(UpperCAmelCase_ ,				output_word_offsets=UpperCAmelCase_      )

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

       self.assertListEqual(
           [' '.join(self.get_from_offsets(UpperCAmelCase_ ,				'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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       import torch

       UpperCamelCase__         =    load_dataset('common_voice' ,				'en' ,				split='train' ,				streaming=UpperCAmelCase_      )
       UpperCamelCase__         =    ds.cast_column('audio' ,				datasets.Audio(sampling_rate=1_6000      )      )
       UpperCamelCase__         =    iter(UpperCAmelCase_      )
       UpperCamelCase__         =    next(UpperCAmelCase_      )

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

       with torch.no_grad():
           UpperCamelCase__         =    model(UpperCAmelCase_      ).logits.cpu().numpy()

       UpperCamelCase__         =    processor.decode(logits[0] ,				output_word_offsets=UpperCAmelCase_      )

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

       UpperCamelCase__         =    '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(UpperCAmelCase_ ,				'word'      )      ) ,				UpperCAmelCase_      )
       self.assertEqual(' '.join(self.get_from_offsets(UpperCAmelCase_ ,				'word'      )      ) ,				output.text      )

       # output times
       UpperCamelCase__         =    torch.tensor(self.get_from_offsets(UpperCAmelCase_ ,				'start_time'      )      )
       UpperCamelCase__         =    torch.tensor(self.get_from_offsets(UpperCAmelCase_ ,				'end_time'      )      )

       # fmt: off
       UpperCamelCase__         =    torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599]      )
       UpperCamelCase__         =    torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 6.94]      )
       # fmt: on

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













"""simple docstring"""





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


if TYPE_CHECKING:
  from ...processing_utils import ProcessorMixin
  from ...utils import TensorType


A__					: Any=	logging.get_logger(__name__)

A__					: str=	{
    """microsoft/layoutlmv3-base""": """https://huggingface.co/microsoft/layoutlmv3-base/resolve/main/config.json""",
}
class    __lowerCamelCase    (  _a  ):
   a      :				List[str] 						="""layoutlmv3"""

   def __init__(					self ,				snake_case_=5_0265 ,				snake_case_=768 ,				snake_case_=12 ,				snake_case_=12 ,				snake_case_=3072 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=512 ,				snake_case_=2 ,				snake_case_=0.02 ,				snake_case_=1E-5 ,				snake_case_=1 ,				snake_case_=0 ,				snake_case_=2 ,				snake_case_=1024 ,				snake_case_=128 ,				snake_case_=128 ,				snake_case_=True ,				snake_case_=32 ,				snake_case_=128 ,				snake_case_=64 ,				snake_case_=256 ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=224 ,				snake_case_=3 ,				snake_case_=16 ,				snake_case_=None ,				**snake_case_ ,				)		->       Union[str, Any]:
       super().__init__(
           vocab_size=snake_case_ ,				hidden_size=snake_case_ ,				num_hidden_layers=snake_case_ ,				num_attention_heads=snake_case_ ,				intermediate_size=snake_case_ ,				hidden_act=snake_case_ ,				hidden_dropout_prob=snake_case_ ,				attention_probs_dropout_prob=snake_case_ ,				max_position_embeddings=snake_case_ ,				type_vocab_size=snake_case_ ,				initializer_range=snake_case_ ,				layer_norm_eps=snake_case_ ,				pad_token_id=snake_case_ ,				bos_token_id=snake_case_ ,				eos_token_id=snake_case_ ,				**snake_case_ ,				)
       UpperCamelCase__         =    max_ad_position_embeddings
       UpperCamelCase__         =    coordinate_size
       UpperCamelCase__         =    shape_size
       UpperCamelCase__         =    has_relative_attention_bias
       UpperCamelCase__         =    rel_pos_bins
       UpperCamelCase__         =    max_rel_pos
       UpperCamelCase__         =    has_spatial_attention_bias
       UpperCamelCase__         =    rel_ad_pos_bins
       UpperCamelCase__         =    max_rel_ad_pos
       UpperCamelCase__         =    text_embed
       UpperCamelCase__         =    visual_embed
       UpperCamelCase__         =    input_size
       UpperCamelCase__         =    num_channels
       UpperCamelCase__         =    patch_size
       UpperCamelCase__         =    classifier_dropout







class    __lowerCamelCase    (  _a  ):
   a      :				Tuple 						=version.parse("""1.12"""  )

   @property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Mapping[str, Mapping[int, str]]:
       # The order of inputs is different for question answering and sequence classification
       if self.task in ["question-answering", "sequence-classification"]:
           return OrderedDict(
               [
                   ('input_ids', {0: 'batch', 1: 'sequence'}),
                   ('attention_mask', {0: 'batch', 1: 'sequence'}),
                   ('bbox', {0: 'batch', 1: 'sequence'}),
                   ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
               ]      )
       else:
           return OrderedDict(
               [
                   ('input_ids', {0: 'batch', 1: 'sequence'}),
                   ('bbox', {0: 'batch', 1: 'sequence'}),
                   ('attention_mask', {0: 'batch', 1: 'sequence'}),
                   ('pixel_values', {0: 'batch', 1: 'num_channels'}),
               ]      )

   @property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       float:
       return 1E-5

   @property
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       return 12







   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ = -1 ,				snake_case_ = -1 ,				snake_case_ = False ,				snake_case_ = None ,				snake_case_ = 3 ,				snake_case_ = 40 ,				snake_case_ = 40 ,				)		->       Mapping[str, Any]:
       setattr(processor.image_processor ,				'apply_ocr' ,				snake_case_      )

       # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
       UpperCamelCase__         =    compute_effective_axis_dimension(
           snake_case_ ,				fixed_dimension=OnnxConfig.default_fixed_batch ,				num_token_to_add=0      )
       # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
       UpperCamelCase__         =    processor.tokenizer.num_special_tokens_to_add(snake_case_      )
       UpperCamelCase__         =    compute_effective_axis_dimension(
           snake_case_ ,				fixed_dimension=OnnxConfig.default_fixed_sequence ,				num_token_to_add=snake_case_      )
       # Generate dummy inputs according to compute batch and sequence
       UpperCamelCase__         =    [[' '.join([processor.tokenizer.unk_token]      ) * seq_length]] * batch_size

       # Generate dummy bounding boxes
       UpperCamelCase__         =    [[[48, 84, 73, 128]]] * batch_size

       # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
       # batch_size = compute_effective_axis_dimension(batch_size, fixed_dimension=OnnxConfig.default_fixed_batch)
       UpperCamelCase__         =    self._generate_dummy_images(snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )

       UpperCamelCase__         =    dict(
           processor(
               snake_case_ ,				text=snake_case_ ,				boxes=snake_case_ ,				return_tensors=snake_case_ ,				)      )

       return inputs




