'''simple docstring'''

import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


lowerCAmelCase_ : Any						  =      get_tests_dir("fixtures/spiece.model")





@require_sentencepiece
@require_tokenizers
class 							lowercase						(						__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=DebertaVaTokenizer
   lowerCamelCase_    					=DebertaVaTokenizerFast
   lowerCamelCase_    					=True
   lowerCamelCase_    					=True


   def __UpperCAmelCase       (   self				:	Dict)      ->					Union[str, Any]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		unk_token="<unk>")
         tokenizer.save_pretrained(self.tmpdirname)


   def __UpperCAmelCase       (   self				:	List[Any]   ,		__lowerCAmelCase				:	str)      ->					Any:
         lowercase_     =      "this is a test"
         lowercase_     =      "this is a test"
         return input_text, output_text


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Optional[int]:
         lowercase_     =      "<pad>"
         lowercase_     =      0

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


   def __UpperCAmelCase       (   self				:	Any)      ->					int:
         lowercase_     =      list(self.get_tokenizer().get_vocab().keys())
         self.assertEqual(vocab_keys[0]   ,		"<pad>")
         self.assertEqual(vocab_keys[1]   ,		"<unk>")
         self.assertEqual(vocab_keys[-1]   ,		"[PAD]")
         self.assertEqual(len(__lowerCAmelCase)   ,		3_0001)


   def __UpperCAmelCase       (   self				:	List[Any])      ->					Optional[Any]:
         self.assertEqual(self.get_tokenizer().vocab_size   ,		3_0000)


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Dict:
         # fmt: off
         lowercase_     =      " \tHeLLo!how  \n Are yoU?  "
         lowercase_     =      ["▁hello", "!", "how", "▁are", "▁you", "?"]
         # fmt: on

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   @unittest.skip("There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.")
   def __UpperCAmelCase       (   self				:	Optional[int])      ->					str:
         pass


   @unittest.skip("There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.")
   def __UpperCAmelCase       (   self				:	Any)      ->					Union[str, Any]:
         pass


   def __UpperCAmelCase       (   self				:	List[str])      ->					Optional[int]:
         # fmt: off
         lowercase_     =      "I was born in 92000, and this is falsé."
         lowercase_     =      ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
         # fmt: on

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[Any]:
         # fmt: off
         lowercase_     =      "I was born in 92000, and this is falsé."
         lowercase_     =      ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
         # fmt: on

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Dict:
         # fmt: off
         lowercase_     =      "I was born in 92000, and this is falsé."
         lowercase_     =      ["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", ".", ]
         # fmt: on

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Optional[int]:
         # fmt: off
         lowercase_     =      "I was born in 92000, and this is falsé."
         lowercase_     =      ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", "▁", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "▁", ".", ]
         # fmt: on

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	List[str])      ->					int:
         # fmt: off
         lowercase_     =      " \tHeLLo!how  \n Are yoU?  "
         lowercase_     =      ["▁", "<unk>", "e", "<unk>", "o", "!", "how", "▁", "<unk>", "re", "▁yo", "<unk>", "?"]
         # fmt: on

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		do_lower_case=__lowerCAmelCase   ,		split_by_punct=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))

         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Any)      ->					Dict:
         lowercase_     =      self.get_tokenizer()
         lowercase_     =      self.get_rust_tokenizer()

         lowercase_     =      "I was born in 92000, and this is falsé."

         lowercase_     =      tokenizer.convert_ids_to_tokens(tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase))
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      self.get_rust_tokenizer()
         lowercase_     =      tokenizer.encode(__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.encode(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Dict:
         lowercase_     =      "This is a test"
         lowercase_     =      [13, 1, 4398, 25, 21, 1289]
         lowercase_     =      ["▁", "T", "his", "▁is", "▁a", "▁test"]
         lowercase_     =      ["▁", "<unk>", "his", "▁is", "▁a", "▁test"]

         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase   ,		keep_accents=__lowerCAmelCase)
         lowercase_     =      DebertaVaTokenizerFast(__lowerCAmelCase   ,		keep_accents=__lowerCAmelCase)

         lowercase_     =      tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      tokenizer.tokenize(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.tokenize(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         # fmt: off
         lowercase_     =      "I was born in 92000, and this is falsé."
         lowercase_     =      [13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]
         lowercase_     =      ["▁", "I", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "é", ".", ]
         lowercase_     =      ["▁", "<unk>", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", ".", ]
         # fmt: on

         lowercase_     =      tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      tokenizer.tokenize(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      tokenizer.convert_ids_to_tokens(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

         lowercase_     =      rust_tokenizer.encode(__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.tokenize(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         lowercase_     =      rust_tokenizer.convert_ids_to_tokens(__lowerCAmelCase)
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Dict)      ->					Any:
         lowercase_     =      DebertaVaTokenizer(__lowerCAmelCase)

         lowercase_     =      tokenizer.encode("sequence builders")
         lowercase_     =      tokenizer.encode("multi-sequence build")

         lowercase_     =      tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase)
         lowercase_     =      tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase   ,		__lowerCAmelCase)

         self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]   ,		__lowerCAmelCase)
         self.assertEqual(
             [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]   ,		__lowerCAmelCase   ,		)


   @slow
   def __UpperCAmelCase       (   self				:	str)      ->					List[str]:
         # fmt: off
         lowercase_     =      {"input_ids": [[1, 3_9867, 36, 1_9390, 486, 27, 3_5052, 8_1436, 18, 6_0685, 1225, 7, 3_5052, 8_1436, 18, 9367, 1_6899, 18, 1_5937, 53, 594, 773, 18, 1_6287, 3_0465, 36, 1_5937, 6, 4_1139, 38, 3_6979, 6_0763, 191, 6, 3_4132, 99, 6, 5_0538, 390, 4_3230, 6, 3_4132, 2779, 2_0850, 14, 699, 1072, 1194, 36, 382, 1_0901, 53, 7, 699, 1072, 2084, 36, 2_0422, 630, 53, 19, 105, 3049, 1896, 1053, 1_6899, 1506, 11, 3_7978, 4243, 7, 1237, 3_1869, 200, 1_6566, 654, 6, 3_5052, 8_1436, 7, 5_5630, 1_3593, 4, 2], [1, 26, 1_5011, 13, 667, 8, 1053, 18, 2_3611, 1237, 7_2356, 1_2820, 34, 10_4134, 1209, 35, 1_3313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1232, 2864, 1_5785, 1_4951, 105, 5, 8581, 1250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "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, 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], [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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__lowerCAmelCase   ,		model_name="microsoft/deberta-v2-xlarge"   ,		revision="ad6e42c1532ddf3a15c39246b63f5559d558b670"   ,		)







'''simple docstring'''

def __a (	__lowerCamelCase			:						list[int] ,		__lowerCamelCase			:						int				)	->							bool:
      '''simple docstring'''


      lowercase_     =      len(__lowerCamelCase				)
      lowercase_     =      [[False] * (required_sum + 1) for _ in range(arr_len + 1				)]

      # for each arr value, a sum of zero(0) can be formed by not taking any element
      # hence True/1
      for i in range(arr_len + 1				):
            lowercase_     =      True

      # sum is not zero and set is empty then false
      for i in range(1 ,		required_sum + 1				):
            lowercase_     =      False

      for i in range(1 ,		arr_len + 1				):
            for j in range(1 ,		required_sum + 1				):
                  if arr[i - 1] > j:
                        lowercase_     =      subset[i - 1][j]
                  if arr[i - 1] <= j:
                        lowercase_     =      subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

      return subset[arr_len][required_sum]


if __name__ == "__main__":
       import doctest

       doctest.testmod()






