


import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCamelCase    :						Tuple     =							get_tests_dir('fixtures/test_sentencepiece.model')


if is_torch_available():
    from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

__UpperCamelCase    :						str     =							256047
__UpperCamelCase    :						Tuple     =							256145



@require_sentencepiece
@require_tokenizers
class 							_UpperCamelCase (						lowerCAmelCase__,unittest.TestCase						):

   '''simple docstring'''







   a_				:							Dict    = NllbTokenizer
   a_				:							List[Any]    = NllbTokenizerFast
   a_				:							Optional[int]    = True
   a_				:							Optional[int]    = True
   a_				:							List[str]    = {}

   def   _snake_case    (  self  : Any							):






         '''simple docstring'''



         super().setUp()

         # We have a SentencePiece fixture for testing
         __lowerCamelCase     :      Optional[int]       						=						NllbTokenizer(_lowerCamelCase       ,  keep_accents=_lowerCamelCase							)
         tokenizer.save_pretrained(self.tmpdirname							)

   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         __lowerCamelCase     :      List[str]       						=						NllbTokenizer(_lowerCamelCase       ,  keep_accents=_lowerCamelCase							)

         __lowerCamelCase     :      Optional[int]       						=						tokenizer.tokenize("""This is a test"""							)
         self.assertListEqual(_lowerCamelCase       ,  ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]							)

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(_lowerCamelCase							)       ,  [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]       ,  )

         __lowerCamelCase     :      List[Any]       						=						tokenizer.tokenize("""I was born in 92000, and this is falsé."""							)
         self.assertListEqual(
             _lowerCamelCase       ,  [
                 SPIECE_UNDERLINE + """I""",
                 SPIECE_UNDERLINE + """was""",
                 SPIECE_UNDERLINE + """b""",
                 """or""",
                 """n""",
                 SPIECE_UNDERLINE + """in""",
                 SPIECE_UNDERLINE + """""",
                 """9""",
                 """2""",
                 """0""",
                 """0""",
                 """0""",
                 """,""",
                 SPIECE_UNDERLINE + """and""",
                 SPIECE_UNDERLINE + """this""",
                 SPIECE_UNDERLINE + """is""",
                 SPIECE_UNDERLINE + """f""",
                 """al""",
                 """s""",
                 """é""",
                 """.""",
             ]       ,  )
         __lowerCamelCase     :      Any       						=						tokenizer.convert_tokens_to_ids(_lowerCamelCase							)
         self.assertListEqual(
             _lowerCamelCase       ,  [
                 value + tokenizer.fairseq_offset
                 for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
             ]       ,  )

         __lowerCamelCase     :      Optional[Any]       						=						tokenizer.convert_ids_to_tokens(_lowerCamelCase							)
         self.assertListEqual(
             _lowerCamelCase       ,  [
                 SPIECE_UNDERLINE + """I""",
                 SPIECE_UNDERLINE + """was""",
                 SPIECE_UNDERLINE + """b""",
                 """or""",
                 """n""",
                 SPIECE_UNDERLINE + """in""",
                 SPIECE_UNDERLINE + """""",
                 """<unk>""",
                 """2""",
                 """0""",
                 """0""",
                 """0""",
                 """,""",
                 SPIECE_UNDERLINE + """and""",
                 SPIECE_UNDERLINE + """this""",
                 SPIECE_UNDERLINE + """is""",
                 SPIECE_UNDERLINE + """f""",
                 """al""",
                 """s""",
                 """<unk>""",
                 """.""",
             ]       ,  )

   def   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {})
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
                     __lowerCamelCase     :      Dict       						=						self.rust_tokenizer_class.from_pretrained(_lowerCamelCase       ,  **_lowerCamelCase							)
                     __lowerCamelCase     :      Dict       						=						self.tokenizer_class.from_pretrained(_lowerCamelCase       ,  **_lowerCamelCase							)

                     __lowerCamelCase     :      Dict       						=						tempfile.mkdtemp()

                     __lowerCamelCase     :      Any       						=						tokenizer_r.save_pretrained(_lowerCamelCase							)
                     __lowerCamelCase     :      Dict       						=						tokenizer_p.save_pretrained(_lowerCamelCase							)

                     # Checks it save with the same files + the tokenizer.json file for the fast one
                     self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files							)							)
                     __lowerCamelCase     :      Dict       						=						tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f							)
                     self.assertSequenceEqual(_lowerCamelCase       ,  _lowerCamelCase							)

                     # Checks everything loads correctly in the same way
                     __lowerCamelCase     :      Optional[int]       						=						tokenizer_r.from_pretrained(_lowerCamelCase							)
                     __lowerCamelCase     :      List[Any]       						=						tokenizer_p.from_pretrained(_lowerCamelCase							)

                     # Check special tokens are set accordingly on Rust and Python
                     for key in tokenizer_pp.special_tokens_map:
                           self.assertTrue(hasattr(_lowerCamelCase       ,  _lowerCamelCase							)							)

                     shutil.rmtree(_lowerCamelCase							)

                     # Save tokenizer rust, legacy_format=True
                     __lowerCamelCase     :      Any       						=						tempfile.mkdtemp()

                     __lowerCamelCase     :      str       						=						tokenizer_r.save_pretrained(_lowerCamelCase       ,  legacy_format=_lowerCamelCase							)
                     __lowerCamelCase     :      int       						=						tokenizer_p.save_pretrained(_lowerCamelCase							)

                     # Checks it save with the same files
                     self.assertSequenceEqual(_lowerCamelCase       ,  _lowerCamelCase							)

                     # Checks everything loads correctly in the same way
                     __lowerCamelCase     :      List[str]       						=						tokenizer_r.from_pretrained(_lowerCamelCase							)
                     __lowerCamelCase     :      List[Any]       						=						tokenizer_p.from_pretrained(_lowerCamelCase							)

                     # Check special tokens are set accordingly on Rust and Python
                     for key in tokenizer_pp.special_tokens_map:
                           self.assertTrue(hasattr(_lowerCamelCase       ,  _lowerCamelCase							)							)

                     shutil.rmtree(_lowerCamelCase							)

                     # Save tokenizer rust, legacy_format=False
                     __lowerCamelCase     :      List[Any]       						=						tempfile.mkdtemp()

                     __lowerCamelCase     :      Tuple       						=						tokenizer_r.save_pretrained(_lowerCamelCase       ,  legacy_format=_lowerCamelCase							)
                     __lowerCamelCase     :      int       						=						tokenizer_p.save_pretrained(_lowerCamelCase							)

                     # Checks it saved the tokenizer.json file
                     self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files							)							)

                     # Checks everything loads correctly in the same way
                     __lowerCamelCase     :      Union[str, Any]       						=						tokenizer_r.from_pretrained(_lowerCamelCase							)
                     __lowerCamelCase     :      int       						=						tokenizer_p.from_pretrained(_lowerCamelCase							)

                     # Check special tokens are set accordingly on Rust and Python
                     for key in tokenizer_pp.special_tokens_map:
                           self.assertTrue(hasattr(_lowerCamelCase       ,  _lowerCamelCase							)							)

                     shutil.rmtree(_lowerCamelCase							)

   @require_torch
   def   _snake_case    (  self  : List[Any]							):






         '''simple docstring'''



         if not self.test_seqaseq:
               return

         __lowerCamelCase     :      List[str]       						=						self.get_tokenizers()
         for tokenizer in tokenizers:
               with self.subTest(F"""{tokenizer.__class__.__name__}"""							):
                     # Longer text that will definitely require truncation.
                     __lowerCamelCase     :      Optional[Any]       						=						[
                         """ UN Chief Says There Is No Military Solution in Syria""",
                         """ Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for"""
                         """ Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons"""
                         """ will only worsen the violence and misery for millions of people.""",
                     ]
                     __lowerCamelCase     :      Union[str, Any]       						=						[
                         """Şeful ONU declară că nu există o soluţie militară în Siria""",
                         """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al"""
                         """ Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi"""
                         """ că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
                     ]
                     try:
                           __lowerCamelCase     :      List[Any]       						=						tokenizer.prepare_seqaseq_batch(
                               src_texts=_lowerCamelCase       ,  tgt_texts=_lowerCamelCase       ,  max_length=3       ,  max_target_length=1_0       ,  return_tensors="""pt"""       ,  src_lang="""eng_Latn"""       ,  tgt_lang="""ron_Latn"""       ,  )
                     except NotImplementedError:
                           return
                     self.assertEqual(batch.input_ids.shape[1]       ,  3							)
                     self.assertEqual(batch.labels.shape[1]       ,  1_0							)
                     # max_target_length will default to max_length if not specified
                     __lowerCamelCase     :      Any       						=						tokenizer.prepare_seqaseq_batch(
                         _lowerCamelCase       ,  tgt_texts=_lowerCamelCase       ,  max_length=3       ,  return_tensors="""pt"""							)
                     self.assertEqual(batch.input_ids.shape[1]       ,  3							)
                     self.assertEqual(batch.labels.shape[1]       ,  3							)

                     __lowerCamelCase     :      Optional[Any]       						=						tokenizer.prepare_seqaseq_batch(
                         src_texts=_lowerCamelCase       ,  max_length=3       ,  max_target_length=1_0       ,  return_tensors="""pt"""							)
                     self.assertEqual(batch_encoder_only.input_ids.shape[1]       ,  3							)
                     self.assertEqual(batch_encoder_only.attention_mask.shape[1]       ,  3							)
                     self.assertNotIn("""decoder_input_ids"""       ,  _lowerCamelCase							)

   @unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece."""							)
   def   _snake_case    (  self  : Any							):






         '''simple docstring'''



         pass


   def   _snake_case    (  self  : str							):






         '''simple docstring'''



         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
                     __lowerCamelCase     :      Union[str, Any]       						=						[AddedToken("""<special>"""       ,  lstrip=_lowerCamelCase							)]

                     __lowerCamelCase     :      Any       						=						self.rust_tokenizer_class.from_pretrained(
                         _lowerCamelCase       ,  additional_special_tokens=_lowerCamelCase       ,  **_lowerCamelCase							)
                     __lowerCamelCase     :      Dict       						=						tokenizer_r.encode("""Hey this is a <special> token"""							)

                     __lowerCamelCase     :      Any       						=						tokenizer_r.encode("""<special>"""       ,  add_special_tokens=_lowerCamelCase							)[0]

                     self.assertTrue(special_token_id in r_output							)

                     if self.test_slow_tokenizer:
                           __lowerCamelCase     :      Optional[Any]       						=						self.rust_tokenizer_class.from_pretrained(
                               _lowerCamelCase       ,  additional_special_tokens=_lowerCamelCase       ,  **_lowerCamelCase       ,  )
                           __lowerCamelCase     :      str       						=						self.tokenizer_class.from_pretrained(
                               _lowerCamelCase       ,  additional_special_tokens=_lowerCamelCase       ,  **_lowerCamelCase							)

                           __lowerCamelCase     :      str       						=						tokenizer_p.encode("""Hey this is a <special> token"""							)

                           __lowerCamelCase     :      Any       						=						tokenizer_cr.encode("""Hey this is a <special> token"""							)

                           self.assertEqual(_lowerCamelCase       ,  _lowerCamelCase							)
                           self.assertEqual(_lowerCamelCase       ,  _lowerCamelCase							)
                           self.assertTrue(special_token_id in p_output							)
                           self.assertTrue(special_token_id in cr_output							)



@require_torch
@require_sentencepiece
@require_tokenizers
class 							_UpperCamelCase (						unittest.TestCase						):

   '''simple docstring'''







   a_				:							int    = "facebook/nllb-200-distilled-600M"
   a_				:							Union[str, Any]    = [
       " UN Chief Says There Is No Military Solution in Syria",
       " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
   ]
   a_				:							int    = [
       "Şeful ONU declară că nu există o soluţie militară în Siria",
       "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
       " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
       " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
   ]
   a_				:							Any    = [
       25_6047,
       1_6297,
       13_4408,
       8165,
       24_8066,
       1_4734,
       950,
       1135,
       10_5721,
       3573,
       83,
       2_7352,
       108,
       4_9486,
       2,
   ]

   @classmethod
   def   _snake_case    (  cls  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						NllbTokenizer.from_pretrained(
             cls.checkpoint_name       ,  src_lang="""eng_Latn"""       ,  tgt_lang="""ron_Latn"""							)
         __lowerCamelCase     :      Dict       						=						1
         return cls

   def   _snake_case    (  self  : Dict							):






         '''simple docstring'''



         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""]       ,  2_5_6_0_0_1							)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""]       ,  2_5_6_0_0_2							)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""]       ,  2_5_6_0_5_7							)

   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Dict       						=						self.tokenizer.batch_encode_plus(self.src_text							).input_ids[0]
         self.assertListEqual(self.expected_src_tokens       ,  _lowerCamelCase							)

   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         self.assertIn(_lowerCamelCase       ,  self.tokenizer.all_special_ids							)
         # fmt: off
         __lowerCamelCase     :      List[str]       						=						[RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7]
         # fmt: on

         __lowerCamelCase     :      str       						=						self.tokenizer.decode(_lowerCamelCase       ,  skip_special_tokens=_lowerCamelCase							)
         __lowerCamelCase     :      List[Any]       						=						self.tokenizer.decode(generated_ids[1:]       ,  skip_special_tokens=_lowerCamelCase							)
         self.assertEqual(_lowerCamelCase       ,  _lowerCamelCase							)
         self.assertNotIn(self.tokenizer.eos_token       ,  _lowerCamelCase							)

   def   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						["""this is gunna be a long sentence """ * 2_0]
         assert isinstance(src_text[0]       ,  _lowerCamelCase							)
         __lowerCamelCase     :      Tuple       						=						1_0
         __lowerCamelCase     :      Any       						=						self.tokenizer(_lowerCamelCase       ,  max_length=_lowerCamelCase       ,  truncation=_lowerCamelCase							).input_ids[0]
         self.assertEqual(ids[-1]       ,  2							)
         self.assertEqual(ids[0]       ,  _lowerCamelCase							)
         self.assertEqual(len(_lowerCamelCase							)       ,  _lowerCamelCase							)

   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]							)       ,  [2_5_6_2_0_3, 3]							)

   def   _snake_case    (  self  : List[str]							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, Any]       						=						tempfile.mkdtemp()
         __lowerCamelCase     :      str       						=						self.tokenizer.fairseq_tokens_to_ids
         self.tokenizer.save_pretrained(_lowerCamelCase							)
         __lowerCamelCase     :      Optional[int]       						=						NllbTokenizer.from_pretrained(_lowerCamelCase							)
         self.assertDictEqual(new_tok.fairseq_tokens_to_ids       ,  _lowerCamelCase							)

   @require_torch
   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      Dict       						=						self.tokenizer(
             self.src_text       ,  text_target=self.tgt_text       ,  padding=_lowerCamelCase       ,  truncation=_lowerCamelCase       ,  max_length=len(self.expected_src_tokens							)       ,  return_tensors="""pt"""       ,  )
         __lowerCamelCase     :      Any       						=						shift_tokens_right(
             batch["""labels"""]       ,  self.tokenizer.pad_token_id       ,  self.tokenizer.lang_code_to_id["""ron_Latn"""]							)

         self.assertIsInstance(_lowerCamelCase       ,  _lowerCamelCase							)

         self.assertEqual((2, 1_5)       ,  batch.input_ids.shape							)
         self.assertEqual((2, 1_5)       ,  batch.attention_mask.shape							)
         __lowerCamelCase     :      Dict       						=						batch.input_ids.tolist()[0]
         self.assertListEqual(self.expected_src_tokens       ,  _lowerCamelCase							)
         self.assertEqual(_lowerCamelCase       ,  batch.decoder_input_ids[0, 0]							)  # EOS
         # Test that special tokens are reset
         self.assertEqual(self.tokenizer.prefix_tokens       ,  [EN_CODE]							)
         self.assertEqual(self.tokenizer.suffix_tokens       ,  [self.tokenizer.eos_token_id]							)

   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						self.tokenizer(self.src_text       ,  padding=_lowerCamelCase       ,  truncation=_lowerCamelCase       ,  max_length=3       ,  return_tensors="""pt"""							)
         __lowerCamelCase     :      Optional[int]       						=						self.tokenizer(
             text_target=self.tgt_text       ,  padding=_lowerCamelCase       ,  truncation=_lowerCamelCase       ,  max_length=1_0       ,  return_tensors="""pt"""							)
         __lowerCamelCase     :      str       						=						targets["""input_ids"""]
         __lowerCamelCase     :      Tuple       						=						shift_tokens_right(
             _lowerCamelCase       ,  self.tokenizer.pad_token_id       ,  decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]       ,  )

         self.assertEqual(batch.input_ids.shape[1]       ,  3							)
         self.assertEqual(batch.decoder_input_ids.shape[1]       ,  1_0							)

   @require_torch
   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      List[str]       						=						self.tokenizer._build_translation_inputs(
             """A test"""       ,  return_tensors="""pt"""       ,  src_lang="""eng_Latn"""       ,  tgt_lang="""fra_Latn"""							)

         self.assertEqual(
             nested_simplify(_lowerCamelCase							)       ,  {
                 # A, test, EOS, en_XX
                 """input_ids""": [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]],
                 """attention_mask""": [[1, 1, 1, 1]],
                 # ar_AR
                 """forced_bos_token_id""": 2_5_6_0_5_7,
             }       ,  )


   @require_torch
   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      str       						=						True
         __lowerCamelCase     :      Dict       						=						self.tokenizer(
             """UN Chief says there is no military solution in Syria"""       ,  src_lang="""eng_Latn"""       ,  tgt_lang="""fra_Latn"""							)
         self.assertEqual(
             inputs.input_ids       ,  [1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7]							)

         __lowerCamelCase     :      str       						=						False
         __lowerCamelCase     :      int       						=						self.tokenizer(
             """UN Chief says there is no military solution in Syria"""       ,  src_lang="""eng_Latn"""       ,  tgt_lang="""fra_Latn"""							)
         self.assertEqual(
             inputs.input_ids       ,  [2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2]							)







from typing import TYPE_CHECKING

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


__UpperCamelCase    :						Union[str, Any]     =							{
    'configuration_layoutlmv2': ['LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMv2Config'],
    'processing_layoutlmv2': ['LayoutLMv2Processor'],
    'tokenization_layoutlmv2': ['LayoutLMv2Tokenizer'],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						List[str]     =							['LayoutLMv2TokenizerFast']

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						List[str]     =							['LayoutLMv2FeatureExtractor']
    __UpperCamelCase    :						Union[str, Any]     =							['LayoutLMv2ImageProcessor']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						Dict     =							[
        'LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST',
        'LayoutLMv2ForQuestionAnswering',
        'LayoutLMv2ForSequenceClassification',
        'LayoutLMv2ForTokenClassification',
        'LayoutLMv2Layer',
        'LayoutLMv2Model',
        'LayoutLMv2PreTrainedModel',
    ]

if TYPE_CHECKING:
    from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
    from .processing_layoutlmva import LayoutLMvaProcessor
    from .tokenization_layoutlmva import LayoutLMvaTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_layoutlmva import (
            LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
            LayoutLMvaForQuestionAnswering,
            LayoutLMvaForSequenceClassification,
            LayoutLMvaForTokenClassification,
            LayoutLMvaLayer,
            LayoutLMvaModel,
            LayoutLMvaPreTrainedModel,
        )
else:
    import sys

    __UpperCamelCase    :						Optional[Any]     =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



