

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


lowerCAmelCase							:  Optional[Any]   	=						get_tests_dir("""fixtures/test_sentencepiece.model""")


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

lowerCAmelCase							:  Optional[Any]   	=						256047
lowerCAmelCase							:  List[Any]   	=						256145



@require_sentencepiece
@require_tokenizers
class   __lowercase				( lowerCAmelCase_		,       unittest.TestCase	):




			"""simple docstring"""







			_UpperCAmelCase   :							Union[str, Any]										=     NllbTokenizer
			_UpperCAmelCase   :							Any										=     NllbTokenizerFast
			_UpperCAmelCase   :							List[Any]										=     True
			_UpperCAmelCase   :							List[str]										=     True
			_UpperCAmelCase   :							Dict										=     {}



			def        _SCREAMING_SNAKE_CASE			( self  :     Dict):
									super().setUp()

									# We have a SentencePiece fixture for testing
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       NllbTokenizer(lowerCAmelCase__   ,						keep_accents=lowerCAmelCase__)
									tokenizer.save_pretrained(self.tmpdirname)



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[Any]):
									SCREAMING_SNAKE_CASE_: int  		=       NllbTokenizer(lowerCAmelCase__   ,						keep_accents=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_: List[str]  		=       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 [285, 46, 10, 170, 382]]   ,						)

									SCREAMING_SNAKE_CASE_: 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",
									        "é",
									        ".",
									    ]   ,						)
									SCREAMING_SNAKE_CASE_: Any  		=       tokenizer.convert_tokens_to_ids(lowerCAmelCase__)
									self.assertListEqual(
									    lowerCAmelCase__   ,						[
									        value + tokenizer.fairseq_offset
									        for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
									    ]   ,						)

									SCREAMING_SNAKE_CASE_: List[str]  		=       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        _SCREAMING_SNAKE_CASE			( self  :     List[Any]):
									SCREAMING_SNAKE_CASE_: List[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})"):
																					SCREAMING_SNAKE_CASE_: List[Any]  		=       self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__   ,						**lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: str  		=       self.tokenizer_class.from_pretrained(lowerCAmelCase__   ,						**lowerCAmelCase__)

																					SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       tempfile.mkdtemp()

																					SCREAMING_SNAKE_CASE_: Optional[int]  		=       tokenizer_r.save_pretrained(lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: List[str]  		=       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))
																					SCREAMING_SNAKE_CASE_: List[str]  		=       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
																					SCREAMING_SNAKE_CASE_: Optional[int]  		=       tokenizer_r.from_pretrained(lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: 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
																					SCREAMING_SNAKE_CASE_: Optional[Any]  		=       tempfile.mkdtemp()

																					SCREAMING_SNAKE_CASE_: str  		=       tokenizer_r.save_pretrained(lowerCAmelCase__   ,						legacy_format=lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: str  		=       tokenizer_p.save_pretrained(lowerCAmelCase__)

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

																					# Checks everything loads correctly in the same way
																					SCREAMING_SNAKE_CASE_: List[Any]  		=       tokenizer_r.from_pretrained(lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: Optional[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
																					SCREAMING_SNAKE_CASE_: Tuple  		=       tempfile.mkdtemp()

																					SCREAMING_SNAKE_CASE_: int  		=       tokenizer_r.save_pretrained(lowerCAmelCase__   ,						legacy_format=lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: Optional[Any]  		=       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
																					SCREAMING_SNAKE_CASE_: List[str]  		=       tokenizer_r.from_pretrained(lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: Optional[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__)



			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     Any):
									if not self.test_seqaseq:
															return

									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       self.get_tokenizers()
									for tokenizer in tokenizers:
															with self.subTest(F"{tokenizer.__class__.__name__}"):
																					# Longer text that will definitely require truncation.
																					SCREAMING_SNAKE_CASE_: 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.''',
																					]
																					SCREAMING_SNAKE_CASE_: Optional[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:
																											SCREAMING_SNAKE_CASE_: Dict  		=       tokenizer.prepare_seqaseq_batch(
																											    src_texts=lowerCAmelCase__   ,						tgt_texts=lowerCAmelCase__   ,						max_length=3   ,						max_target_length=10   ,						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]   ,						10)
																					# max_target_length will default to max_length if not specified
																					SCREAMING_SNAKE_CASE_: List[str]  		=       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)

																					SCREAMING_SNAKE_CASE_: Dict  		=       tokenizer.prepare_seqaseq_batch(
																					    src_texts=lowerCAmelCase__   ,						max_length=3   ,						max_target_length=10   ,						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        _SCREAMING_SNAKE_CASE			( self  :     Tuple):
									pass




			def        _SCREAMING_SNAKE_CASE			( self  :     int):
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"):
																					SCREAMING_SNAKE_CASE_: List[Any]  		=       [AddedToken("<special>"   ,						lstrip=lowerCAmelCase__)]

																					SCREAMING_SNAKE_CASE_: List[Any]  		=       self.rust_tokenizer_class.from_pretrained(
																					    lowerCAmelCase__   ,						additional_special_tokens=lowerCAmelCase__   ,						**lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_: Any  		=       tokenizer_r.encode("Hey this is a <special> token")

																					SCREAMING_SNAKE_CASE_: Tuple  		=       tokenizer_r.encode("<special>"   ,						add_special_tokens=lowerCAmelCase__)[0]

																					self.assertTrue(special_token_id in r_output)

																					if self.test_slow_tokenizer:
																											SCREAMING_SNAKE_CASE_: str  		=       self.rust_tokenizer_class.from_pretrained(
																											    lowerCAmelCase__   ,						additional_special_tokens=lowerCAmelCase__   ,						**lowerCAmelCase__   ,						)
																											SCREAMING_SNAKE_CASE_: int  		=       self.tokenizer_class.from_pretrained(
																											    lowerCAmelCase__   ,						additional_special_tokens=lowerCAmelCase__   ,						**lowerCAmelCase__)

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

																											SCREAMING_SNAKE_CASE_: Dict  		=       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   __lowercase				( unittest.TestCase	):




			"""simple docstring"""







			_UpperCAmelCase   :							str										=     '''facebook/nllb-200-distilled-600M'''
			_UpperCAmelCase   :							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.''',
			]
			_UpperCAmelCase   :							List[str]										=     [
			    '''Ş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.''',
			]
			_UpperCAmelCase   :							Optional[int]										=     [
			    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        _SCREAMING_SNAKE_CASE			( cls  :     Optional[Any]):
									SCREAMING_SNAKE_CASE_: NllbTokenizer  		=       NllbTokenizer.from_pretrained(
									    cls.checkpoint_name   ,						src_lang="eng_Latn"   ,						tgt_lang="ron_Latn")
									SCREAMING_SNAKE_CASE_: Dict  		=       1
									return cls



			def        _SCREAMING_SNAKE_CASE			( self  :     int):
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Arab"]   ,						25_6001)
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Latn"]   ,						25_6002)
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["fra_Latn"]   ,						25_6057)



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]):
									SCREAMING_SNAKE_CASE_: List[Any]  		=       self.tokenizer.batch_encode_plus(self.src_text).input_ids[0]
									self.assertListEqual(self.expected_src_tokens   ,						lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]):
									self.assertIn(lowerCAmelCase__   ,						self.tokenizer.all_special_ids)
									# fmt: off
									SCREAMING_SNAKE_CASE_: Tuple  		=       [RO_CODE, 4254, 9_8068, 11_2923, 3_9072, 3909, 713, 10_2767, 26, 1_7314, 3_5642, 1_4683, 3_3118, 2022, 6_6987, 2, 25_6047]
									# fmt: on

									SCREAMING_SNAKE_CASE_: List[Any]  		=       self.tokenizer.decode(lowerCAmelCase__   ,						skip_special_tokens=lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: int  		=       self.tokenizer.decode(generated_ids[1:]   ,						skip_special_tokens=lowerCAmelCase__)
									self.assertEqual(lowerCAmelCase__   ,						lowerCAmelCase__)
									self.assertNotIn(self.tokenizer.eos_token   ,						lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]):
									SCREAMING_SNAKE_CASE_: Any  		=       ['''this is gunna be a long sentence ''' * 20]
									assert isinstance(src_text[0]   ,						lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: int  		=       10
									SCREAMING_SNAKE_CASE_: List[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        _SCREAMING_SNAKE_CASE			( self  :     List[str]):
									self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"])   ,						[25_6203, 3])



			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]):
									SCREAMING_SNAKE_CASE_: str  		=       tempfile.mkdtemp()
									SCREAMING_SNAKE_CASE_: str  		=       self.tokenizer.fairseq_tokens_to_ids
									self.tokenizer.save_pretrained(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: str  		=       NllbTokenizer.from_pretrained(lowerCAmelCase__)
									self.assertDictEqual(new_tok.fairseq_tokens_to_ids   ,						lowerCAmelCase__)



			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     int):
									SCREAMING_SNAKE_CASE_: int  		=       self.tokenizer(
									    self.src_text   ,						text_target=self.tgt_text   ,						padding=lowerCAmelCase__   ,						truncation=lowerCAmelCase__   ,						max_length=len(self.expected_src_tokens)   ,						return_tensors="pt"   ,						)
									SCREAMING_SNAKE_CASE_: str  		=       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, 15)   ,						batch.input_ids.shape)
									self.assertEqual((2, 15)   ,						batch.attention_mask.shape)
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       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        _SCREAMING_SNAKE_CASE			( self  :     Union[str, Any]):
									SCREAMING_SNAKE_CASE_: Tuple  		=       self.tokenizer(self.src_text   ,						padding=lowerCAmelCase__   ,						truncation=lowerCAmelCase__   ,						max_length=3   ,						return_tensors="pt")
									SCREAMING_SNAKE_CASE_: Dict  		=       self.tokenizer(
									    text_target=self.tgt_text   ,						padding=lowerCAmelCase__   ,						truncation=lowerCAmelCase__   ,						max_length=10   ,						return_tensors="pt")
									SCREAMING_SNAKE_CASE_: List[str]  		=       targets['''input_ids''']
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       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]   ,						10)



			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     Any):
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       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": [[25_6047, 70, 7356, 2]],
									        "attention_mask": [[1, 1, 1, 1]],
									        # ar_AR
									        "forced_bos_token_id": 25_6057,
									    }   ,						)




			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]):
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       True
									SCREAMING_SNAKE_CASE_: List[str]  		=       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_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2, 25_6047])

									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       False
									SCREAMING_SNAKE_CASE_: 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   ,						[25_6047, 1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2])











"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_lowercase : List[Any]      						=						{
    "configuration_tapas": ["TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP", "TapasConfig"],
    "tokenization_tapas": ["TapasTokenizer"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase : Optional[Any]      						=						[
		    "TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TapasForMaskedLM",
		    "TapasForQuestionAnswering",
		    "TapasForSequenceClassification",
		    "TapasModel",
		    "TapasPreTrainedModel",
		    "load_tf_weights_in_tapas",
		]
try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase : str      						=						[
		    "TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TFTapasForMaskedLM",
		    "TFTapasForQuestionAnswering",
		    "TFTapasForSequenceClassification",
		    "TFTapasModel",
		    "TFTapasPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
		from .tokenization_tapas import TapasTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tapas import (
				    TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TapasForMaskedLM,
				    TapasForQuestionAnswering,
				    TapasForSequenceClassification,
				    TapasModel,
				    TapasPreTrainedModel,
				    load_tf_weights_in_tapas,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_tapas import (
				    TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFTapasForMaskedLM,
				    TFTapasForQuestionAnswering,
				    TFTapasForSequenceClassification,
				    TFTapasModel,
				    TFTapasPreTrainedModel,
				)


else:
		import sys

		_lowercase : List[str]      						=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




