"""simple docstring"""




import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_a      :		Tuple           =   get_tests_dir('fixtures/test_sentencepiece.model')
@require_sentencepiece
@require_tokenizers
class 						__A							( SCREAMING_SNAKE_CASE_    ,	unittest.TestCase		):
     _UpperCamelCase							:			Optional[int]							=		ReformerTokenizer
     _UpperCamelCase							:			Tuple							=		ReformerTokenizerFast
     _UpperCamelCase							:			Tuple							=		True
     _UpperCamelCase							:			int							=		False
     _UpperCamelCase							:			Union[str, Any]							=		True






     def     __A  (		self  ):
       super().setUp()

       _lowerCAmelCase						:       Any  			=     ReformerTokenizer(a__				,     keep_accents=a__  )
       tokenizer.save_pretrained(self.tmpdirname  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[int]  			=     """<s>"""
       _lowerCAmelCase						:       Dict  			=     1

       self.assertEqual(self.get_tokenizer()._convert_token_to_id(a__  )				,     a__  )
       self.assertEqual(self.get_tokenizer()._convert_id_to_token(a__  )				,     a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       int  			=     list(self.get_tokenizer().get_vocab().keys()  )

       self.assertEqual(vocab_keys[0]				,     """<unk>"""  )
       self.assertEqual(vocab_keys[1]				,     """<s>"""  )
       self.assertEqual(vocab_keys[-1]				,     """j"""  )
       self.assertEqual(len(a__  )				,     1000  )






     def     __A  (		self  ):
       self.assertEqual(self.get_tokenizer().vocab_size				,     1000  )






     def     __A  (		self  ):
       if not self.test_rust_tokenizer:
         return

       _lowerCAmelCase						:       Any  			=     self.get_tokenizer()
       _lowerCAmelCase						:       Dict  			=     self.get_rust_tokenizer()

       _lowerCAmelCase						:       Any  			=     """I was born in 92000, and this is falsé."""

       _lowerCAmelCase						:       Any  			=     tokenizer.tokenize(a__  )
       _lowerCAmelCase						:       Dict  			=     rust_tokenizer.tokenize(a__  )
       self.assertListEqual(a__				,     a__  )

       _lowerCAmelCase						:       int  			=     tokenizer.encode(a__				,     add_special_tokens=a__  )
       _lowerCAmelCase						:       List[Any]  			=     rust_tokenizer.encode(a__				,     add_special_tokens=a__  )
       self.assertListEqual(a__				,     a__  )

       _lowerCAmelCase						:       Optional[int]  			=     self.get_rust_tokenizer()
       _lowerCAmelCase						:       str  			=     tokenizer.encode(a__  )
       _lowerCAmelCase						:       Dict  			=     rust_tokenizer.encode(a__  )
       self.assertListEqual(a__				,     a__  )






     def     __A  (		self				,     a__=15  ):
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"  ):
           _lowerCAmelCase						:       Any  			=     self.rust_tokenizer_class.from_pretrained(a__				,     **a__  )

           # Simple input
           _lowerCAmelCase						:       List[str]  			=     """This is a simple input"""
           _lowerCAmelCase						:       Optional[int]  			=     ["""This is a simple input 1""", """This is a simple input 2"""]
           _lowerCAmelCase						:       List[Any]  			=     ("""This is a simple input""", """This is a pair""")
           _lowerCAmelCase						:       Optional[Any]  			=     [
               ("""This is a simple input 1""", """This is a simple input 2"""),
               ("""This is a simple pair 1""", """This is a simple pair 2"""),
           ]

           # Simple input tests
           self.assertRaises(a__				,     tokenizer_r.encode				,     a__				,     max_length=a__				,     padding="""max_length"""  )

           # Simple input
           self.assertRaises(a__				,     tokenizer_r.encode_plus				,     a__				,     max_length=a__				,     padding="""max_length"""  )

           # Simple input
           self.assertRaises(
               a__				,     tokenizer_r.batch_encode_plus				,     a__				,     max_length=a__				,     padding="""max_length"""				,     )

           # Pair input
           self.assertRaises(a__				,     tokenizer_r.encode				,     a__				,     max_length=a__				,     padding="""max_length"""  )

           # Pair input
           self.assertRaises(a__				,     tokenizer_r.encode_plus				,     a__				,     max_length=a__				,     padding="""max_length"""  )

           # Pair input
           self.assertRaises(
               a__				,     tokenizer_r.batch_encode_plus				,     a__				,     max_length=a__				,     padding="""max_length"""				,     )






     def     __A  (		self  ):
       pass






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[Any]  			=     ReformerTokenizer(a__				,     keep_accents=a__  )

       _lowerCAmelCase						:       Any  			=     tokenizer.tokenize("""This is a test"""  )
       self.assertListEqual(a__				,     ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]  )

       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(a__  )				,     [285, 46, 10, 170, 382]				,     )

       _lowerCAmelCase						:       List[str]  			=     tokenizer.tokenize("""I was born in 92000, and this is falsé."""  )
       self.assertListEqual(
           a__				,     [
               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						:       Tuple  			=     tokenizer.convert_tokens_to_ids(a__  )
       self.assertListEqual(
           a__				,     [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]				,     )

       _lowerCAmelCase						:       List[str]  			=     tokenizer.convert_ids_to_tokens(a__  )
       self.assertListEqual(
           a__				,     [
               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>""",
               """.""",
           ]				,     )






     @cached_property
     def     __A  (		self  ):
       return ReformerTokenizer.from_pretrained("""google/reformer-crime-and-punishment"""  )






     @slow
     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     """Hello World!"""
       _lowerCAmelCase						:       Tuple  			=     [126, 32, 262, 152, 38, 72, 287]

       self.assertListEqual(a__				,     self.big_tokenizer.encode(a__  )  )






     @slow
     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     (
           """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
           """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
       )
       _lowerCAmelCase						:       Union[str, Any]  			=     [
           108,
           265,
           24,
           111,
           4,
           258,
           156,
           35,
           28,
           275,
           3,
           259,
           297,
           260,
           84,
           4,
           35,
           110,
           44,
           8,
           259,
           91,
           268,
           21,
           11,
           209,
           274,
           109,
           266,
           277,
           117,
           86,
           93,
           315,
           258,
           278,
           258,
           277,
           258,
           0,
           258,
           288,
           258,
           319,
           258,
           0,
           258,
           0,
           258,
           0,
           258,
           0,
           258,
           287,
           258,
           315,
           258,
           289,
           258,
           278,
           99,
           269,
           266,
           262,
           8,
           259,
           241,
           4,
           217,
           230,
           268,
           266,
           55,
           168,
           106,
           75,
           193,
           266,
           223,
           27,
           49,
           26,
           282,
           25,
           264,
           299,
           19,
           26,
           0,
           258,
           277,
           117,
           86,
           93,
           176,
           183,
           270,
           11,
           262,
           42,
           61,
           265,
       ]

       self.assertListEqual(a__				,     self.big_tokenizer.encode(a__  )  )






     @require_torch
     @slow
     def     __A  (		self  ):
       import torch

       from transformers import ReformerConfig, ReformerModel

       # Build sequence
       _lowerCAmelCase						:       Union[str, Any]  			=     list(self.big_tokenizer.get_vocab().keys()  )[:10]
       _lowerCAmelCase						:       Dict  			=     """ """.join(a__  )
       _lowerCAmelCase						:       List[str]  			=     self.big_tokenizer.encode_plus(a__				,     return_tensors="""pt"""  )
       _lowerCAmelCase						:       Optional[int]  			=     self.big_tokenizer.batch_encode_plus([sequence, sequence]				,     return_tensors="""pt"""  )

       _lowerCAmelCase						:       List[Any]  			=     ReformerConfig()
       # The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
       _lowerCAmelCase						:       Optional[int]  			=     encoded_sequence["""input_ids"""].shape
       _lowerCAmelCase						:       Any  			=     ReformerModel(a__  )

       # Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
       assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

       with torch.no_grad():
         model(**a__  )
         model(**a__  )






     @slow
     def     __A  (		self  ):
       # fmt: off
       _lowerCAmelCase						:       Dict  			=     {"""input_ids""": [[108, 265, 24, 111, 4, 258, 156, 7, 51, 279, 58, 7, 76, 25, 69, 278], [140, 243, 264, 134, 17, 267, 77, 263, 22, 262, 297, 258, 304, 177, 279, 266, 14, 89, 13, 35, 261, 299, 272, 137, 275, 278]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
       # fmt: on

       # This tokenizer does not know some characters like ")".
       # That is the reason why we use very simple texts here.
       # Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
       _lowerCAmelCase						:       str  			=     [
           """This is a very simple sentence.""",
           """The quick brown fox jumps over the lazy dog.""",
       ]

       self.tokenizer_integration_test_util(
           expected_encoding=a__				,     model_name="""google/reformer-crime-and-punishment"""				,     revision="""0e6c3decb8211d49bf881013425dc8b0448b3f5a"""				,     padding=a__				,     sequences=a__				,     )









"""simple docstring"""







from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
							from transformers import (
							    AutoConfig,
							    BertConfig,
							    GPTaConfig,
							    TaConfig,
							    TFAutoModel,
							    TFAutoModelForCausalLM,
							    TFAutoModelForMaskedLM,
							    TFAutoModelForPreTraining,
							    TFAutoModelForQuestionAnswering,
							    TFAutoModelForSeqaSeqLM,
							    TFAutoModelForSequenceClassification,
							    TFAutoModelWithLMHead,
							    TFBertForMaskedLM,
							    TFBertForPreTraining,
							    TFBertForQuestionAnswering,
							    TFBertForSequenceClassification,
							    TFBertModel,
							    TFGPTaLMHeadModel,
							    TFRobertaForMaskedLM,
							    TFTaForConditionalGeneration,
							)
							from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
							from transformers import (
							    AutoModel,
							    AutoModelForCausalLM,
							    AutoModelForMaskedLM,
							    AutoModelForPreTraining,
							    AutoModelForQuestionAnswering,
							    AutoModelForSeqaSeqLM,
							    AutoModelForSequenceClassification,
							    AutoModelWithLMHead,
							    BertForMaskedLM,
							    BertForPreTraining,
							    BertForQuestionAnswering,
							    BertForSequenceClassification,
							    BertModel,
							    GPTaLMHeadModel,
							    RobertaForMaskedLM,
							    TaForConditionalGeneration,
							)
@is_pt_tf_cross_test
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		@slow
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Union[str, Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Tuple				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Dict				=			TFAutoModel.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			AutoModel.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Tuple:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Dict				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    str				=			TFAutoModelForPreTraining.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Optional[Any]				=			AutoModelForPreTraining.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Dict:






				"""simple docstring"""



				for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Any				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			TFAutoModelForCausalLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[Any]				=			TFAutoModelForCausalLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			AutoModelForCausalLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[Any]				=			AutoModelForCausalLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Any						)					->		Tuple:






				"""simple docstring"""



				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Any				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Optional[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Optional[Any]:






				"""simple docstring"""



				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    str				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			TFAutoModelForMaskedLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    str				=			TFAutoModelForMaskedLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			AutoModelForMaskedLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Any				=			AutoModelForMaskedLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Dict:






				"""simple docstring"""



				for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Union[str, Any]				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			TFAutoModelForSeqaSeqLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    List[str]				=			TFAutoModelForSeqaSeqLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelForSeqaSeqLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[int]				=			AutoModelForSeqaSeqLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Union[str, Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Tuple				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			TFAutoModelForSequenceClassification.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			AutoModelForSequenceClassification.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    List[Any]				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    str				=			TFAutoModelForQuestionAnswering.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelForQuestionAnswering.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)

				lowercase__   :    Union[str, Any]				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)







		def 					UpperCAmelCase    (	self						:  int						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)

				lowercase__   :    int				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)
