


"""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 							_UpperCAmelCase      (      self							)       ->							List[str]:
          _a    	=				'''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
          _a    	=				dict(zip(__snake_case    ,				range(len(__snake_case							)							)							)							)

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

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

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

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


     def 							_UpperCAmelCase      (      self    ,				**__UpperCAmelCase							)       ->							Optional[Any]:
          _a    	=				self.add_kwargs_tokens_map.copy()
          kwargs.update(__snake_case							)
          return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname    ,				**__snake_case							)


     def 							_UpperCAmelCase      (      self    ,				**__UpperCAmelCase							)       ->							List[Any]:
          return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname    ,				**__snake_case							)


     def 							_UpperCAmelCase      (      self    ,				**__UpperCAmelCase							)       ->							Optional[int]:
          return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name    ,				**__snake_case							)


     def 							_UpperCAmelCase      (      self							)       ->							List[Any]:
          shutil.rmtree(self.tmpdirname							)


     def 							_UpperCAmelCase      (      self							)       ->							Optional[Any]:
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

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

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

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

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


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


     def 							_UpperCAmelCase      (      self							)       ->							Optional[int]:
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

          _a    	=				floats_list((3, 1000)							)

          _a    	=				feature_extractor(__snake_case    ,				return_tensors='''np'''							)
          _a    	=				processor(__snake_case    ,				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 							_UpperCAmelCase      (      self							)       ->							Dict:
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

          _a    	=				'''This is a test string'''

          _a    	=				processor(text=__snake_case							)

          _a    	=				tokenizer(__snake_case							)

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


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase=(2, 10, 16)    ,				__UpperCAmelCase=77							)       ->							str:
          np.random.seed(__snake_case							)
          return np.random.rand(*__snake_case							)


     def 							_UpperCAmelCase      (      self							)       ->							Tuple:
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

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

          _a    	=				processor.decode(__snake_case							)

          _a    	=				decoder.decode_beams(__snake_case							)[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 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							Optional[int]:
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

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

          _a    	=				list(__snake_case							)

          with get_context('''fork'''							).Pool() as p:
               _a    	=				decoder.decode_beams_batch(__snake_case    ,				__snake_case							)

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


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

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

          _a    	=				self._get_dummy_logits()

          _a    	=				15
          _a    	=				-20.0
          _a    	=				-4.0

          _a    	=				processor.batch_decode(
              __snake_case    ,				beam_width=__snake_case    ,				beam_prune_logp=__snake_case    ,				token_min_logp=__snake_case    ,				)
          _a    	=				decoded_processor_out.text

          _a    	=				list(__snake_case							)

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

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

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

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

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


     def 							_UpperCAmelCase      (      self							)       ->							Dict:
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

          _a    	=				self._get_dummy_logits()

          _a    	=				2.0
          _a    	=				5.0
          _a    	=				-20.0
          _a    	=				True

          _a    	=				processor.batch_decode(
              __snake_case    ,				alpha=__snake_case    ,				beta=__snake_case    ,				unk_score_offset=__snake_case    ,				lm_score_boundary=__snake_case    ,				)
          _a    	=				decoded_processor_out.text

          _a    	=				list(__snake_case							)
          decoder.reset_params(
              alpha=__snake_case    ,				beta=__snake_case    ,				unk_score_offset=__snake_case    ,				lm_score_boundary=__snake_case    ,				)

          with get_context('''fork'''							).Pool() as pool:
               _a    	=				decoder.decode_beams_batch(
                   __snake_case    ,				__snake_case    ,				)

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

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


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

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

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


     def 							_UpperCAmelCase      (      self							)       ->							Tuple:
          _a    	=				snapshot_download('''hf-internal-testing/processor_with_lm'''							)

          _a    	=				WavaVecaProcessorWithLM.from_pretrained(__snake_case							)

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

          _a    	=				os.listdir(__snake_case							)
          _a    	=				os.listdir(__snake_case							)

          local_decoder_files.sort()
          expected_decoder_files.sort()

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


     def 							_UpperCAmelCase      (      self							)       ->							List[str]:
          _a    	=				WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''							)
          _a    	=				AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''							)

          _a    	=				floats_list((3, 1000)							)

          _a    	=				processor_wavaveca(__snake_case    ,				return_tensors='''np'''							)
          _a    	=				processor_auto(__snake_case    ,				return_tensors='''np'''							)

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

          _a    	=				self._get_dummy_logits()

          _a    	=				processor_wavaveca.batch_decode(__snake_case							)
          _a    	=				processor_auto.batch_decode(__snake_case							)

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


     def 							_UpperCAmelCase      (      self							)       ->							List[str]:
          _a    	=				self.get_feature_extractor()
          _a    	=				self.get_tokenizer()
          _a    	=				self.get_decoder()

          _a    	=				WavaVecaProcessorWithLM(tokenizer=__snake_case    ,				feature_extractor=__snake_case    ,				decoder=__snake_case							)

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


     @staticmethod
     def 							_UpperCAmelCase      (      __UpperCAmelCase    ,				__UpperCAmelCase							)       ->							Optional[int]:
          _a    	=				[d[key] for d in offsets]
          return retrieved_list


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

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

          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 							_UpperCAmelCase      (      self							)       ->							List[Any]:
          _a    	=				WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''							)
          _a    	=				self._get_dummy_logits()

          _a    	=				processor.batch_decode(__snake_case    ,				output_word_offsets=__snake_case							)

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

          self.assertListEqual(
              [''' '''.join(self.get_from_offsets(__snake_case    ,				'''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 							_UpperCAmelCase      (      self							)       ->							int:
          import torch

          _a    	=				load_dataset('''common_voice'''    ,				'''en'''    ,				split='''train'''    ,				streaming=__snake_case							)
          _a    	=				ds.cast_column('''audio'''    ,				datasets.Audio(sampling_rate=16000							)							)
          _a    	=				iter(__snake_case							)
          _a    	=				next(__snake_case							)

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

          with torch.no_grad():
               _a    	=				model(__snake_case							).logits.cpu().numpy()

          _a    	=				processor.decode(logits[0]    ,				output_word_offsets=__snake_case							)

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

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

          # output times
          _a    	=				torch.tensor(self.get_from_offsets(__snake_case    ,				'''start_time'''							)							)
          _a    	=				torch.tensor(self.get_from_offsets(__snake_case    ,				'''end_time'''							)							)

          # fmt: off
          _a    	=				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]							)
          _a    	=				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(__snake_case    ,				__snake_case    ,				atol=0.01							)							)
          self.assertTrue(torch.allclose(__snake_case    ,				__snake_case    ,				atol=0.01							)							)









"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__snake_case		=       {
    '''configuration_lxmert''': ['''LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LxmertConfig'''],
    '''tokenization_lxmert''': ['''LxmertTokenizer'''],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       ['''LxmertTokenizerFast''']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       [
       '''LxmertEncoder''',
       '''LxmertForPreTraining''',
       '''LxmertForQuestionAnswering''',
       '''LxmertModel''',
       '''LxmertPreTrainedModel''',
       '''LxmertVisualFeatureEncoder''',
       '''LxmertXLayer''',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       [
       '''TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''TFLxmertForPreTraining''',
       '''TFLxmertMainLayer''',
       '''TFLxmertModel''',
       '''TFLxmertPreTrainedModel''',
       '''TFLxmertVisualFeatureEncoder''',
   ]


if TYPE_CHECKING:
   from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig
   from .tokenization_lxmert import LxmertTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_lxmert_fast import LxmertTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_lxmert import (
          LxmertEncoder,
          LxmertForPreTraining,
          LxmertForQuestionAnswering,
          LxmertModel,
          LxmertPreTrainedModel,
          LxmertVisualFeatureEncoder,
          LxmertXLayer,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_lxmert import (
          TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLxmertForPreTraining,
          TFLxmertMainLayer,
          TFLxmertModel,
          TFLxmertPreTrainedModel,
          TFLxmertVisualFeatureEncoder,
      )

else:
   import sys

   __snake_case		=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)