



"""simple docstring"""




import unittest

from transformers import SPIECE_UNDERLINE
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.tokenization_utils import AddedToken

from ...test_tokenization_common import TokenizerTesterMixin


_lowerCAmelCase							:   Any				=				get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")






@require_sentencepiece
@require_tokenizers
class       UpperCAmelCase_    (							_UpperCamelCase			,     unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:  Tuple						=					SpeechTaTokenizer
      __SCREAMING_SNAKE_CASE		:  List[Any]						=					False
      __SCREAMING_SNAKE_CASE		:  List[str]						=					True



      def 		snake_case_   (	self	:      List[str]		):
           super().setUp()

           # We have a SentencePiece fixture for testing
           _UpperCAmelCase     :      int														=       SpeechTaTokenizer(A		)

           _UpperCAmelCase     :      Any														=       AddedToken("<mask>"	,      lstrip=A	,      rstrip=A		)
           _UpperCAmelCase     :      Union[str, Any]														=       mask_token
           tokenizer.add_special_tokens({"mask_token": mask_token}		)
           tokenizer.add_tokens(["<ctc_blank>"]		)

           tokenizer.save_pretrained(self.tmpdirname		)



      def 		snake_case_   (	self	:      Optional[int]	,      A	:      Union[str, Any]		):
           _UpperCAmelCase     :      List[str]														=       "this is a test"
           _UpperCAmelCase     :      Any														=       "this is a test"
           return input_text, output_text



      def 		snake_case_   (	self	:      Any	,      A	:      Union[str, Any]	,      A	:      Tuple=False	,      A	:      int=2_0	,      A	:      Any=5		):
           _UpperCAmelCase							,			_UpperCAmelCase     :      Dict														=       self.get_input_output_texts(A		)
           _UpperCAmelCase     :      Tuple														=       tokenizer.encode(A	,      add_special_tokens=A		)
           _UpperCAmelCase     :      Dict														=       tokenizer.decode(A	,      clean_up_tokenization_spaces=A		)
           return text, ids



      def 		snake_case_   (	self	:      int		):
           _UpperCAmelCase     :      Union[str, Any]														=       "<pad>"
           _UpperCAmelCase     :      Union[str, Any]														=       1

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



      def 		snake_case_   (	self	:      Any		):
           _UpperCAmelCase     :      Optional[Any]														=       list(self.get_tokenizer().get_vocab().keys()		)

           self.assertEqual(vocab_keys[0]	,      "<s>"		)
           self.assertEqual(vocab_keys[1]	,      "<pad>"		)
           self.assertEqual(vocab_keys[-4]	,      "œ"		)
           self.assertEqual(vocab_keys[-2]	,      "<mask>"		)
           self.assertEqual(vocab_keys[-1]	,      "<ctc_blank>"		)
           self.assertEqual(len(A		)	,      8_1		)



      def 		snake_case_   (	self	:      List[str]		):
           self.assertEqual(self.get_tokenizer().vocab_size	,      7_9		)



      def 		snake_case_   (	self	:      Optional[int]		):
           _UpperCAmelCase     :      Dict														=       self.get_tokenizers(do_lower_case=A		)
           for tokenizer in tokenizers:
                with self.subTest(f'{tokenizer.__class__.__name__}'		):
                     _UpperCAmelCase     :      Tuple														=       tokenizer.vocab_size
                     _UpperCAmelCase     :      Optional[Any]														=       len(A		)

                     self.assertNotEqual(A	,      0		)

                     # We usually have added tokens from the start in tests because our vocab fixtures are
                     # smaller than the original vocabs - let's not assert this
                     # self.assertEqual(vocab_size, all_size)

                     _UpperCAmelCase     :      Union[str, Any]														=       ["aaaaa bbbbbb", "cccccccccdddddddd"]
                     _UpperCAmelCase     :      str														=       tokenizer.add_tokens(A		)
                     _UpperCAmelCase     :      Optional[Any]														=       tokenizer.vocab_size
                     _UpperCAmelCase     :      Optional[int]														=       len(A		)

                     self.assertNotEqual(A	,      0		)
                     self.assertEqual(A	,      A		)
                     self.assertEqual(A	,      len(A		)		)
                     self.assertEqual(A	,      all_size + len(A		)		)

                     _UpperCAmelCase     :      str														=       tokenizer.encode("aaaaa bbbbbb low cccccccccdddddddd l"	,      add_special_tokens=A		)

                     self.assertGreaterEqual(len(A		)	,      4		)
                     self.assertGreater(tokens[0]	,      tokenizer.vocab_size - 1		)
                     self.assertGreater(tokens[-3]	,      tokenizer.vocab_size - 1		)

                     _UpperCAmelCase     :      Any														=       {"eos_token": ">>>>|||<||<<|<<", "pad_token": "<<<<<|||>|>>>>|>"}
                     _UpperCAmelCase     :      List[str]														=       tokenizer.add_special_tokens(A		)
                     _UpperCAmelCase     :      Union[str, Any]														=       tokenizer.vocab_size
                     _UpperCAmelCase     :      str														=       len(A		)

                     self.assertNotEqual(A	,      0		)
                     self.assertEqual(A	,      A		)
                     self.assertEqual(A	,      len(A		)		)
                     self.assertEqual(A	,      all_size_a + len(A		)		)

                     _UpperCAmelCase     :      Dict														=       tokenizer.encode(
                         ">>>>|||<||<<|<< aaaaabbbbbb low cccccccccdddddddd <<<<<|||>|>>>>|> l"	,      add_special_tokens=A		)

                     self.assertGreaterEqual(len(A		)	,      6		)
                     self.assertGreater(tokens[0]	,      tokenizer.vocab_size - 1		)
                     self.assertGreater(tokens[0]	,      tokens[1]		)
                     self.assertGreater(tokens[-3]	,      tokenizer.vocab_size - 1		)
                     self.assertGreater(tokens[-3]	,      tokens[-4]		)
                     self.assertEqual(tokens[0]	,      tokenizer.eos_token_id		)
                     self.assertEqual(tokens[-3]	,      tokenizer.pad_token_id		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           pass



      def 		snake_case_   (	self	:      List[Any]		):
           pass



      def 		snake_case_   (	self	:      List[Any]		):
           _UpperCAmelCase     :      List[Any]														=       self.get_tokenizer()

           _UpperCAmelCase     :      Optional[Any]														=       tokenizer.tokenize("This is a test"		)
           # fmt: off
           self.assertListEqual(A	,      [SPIECE_UNDERLINE, "T", "h", "i", "s", SPIECE_UNDERLINE, "i", "s", SPIECE_UNDERLINE, "a", SPIECE_UNDERLINE, "t", "e", "s", "t"]		)
           # fmt: on

           self.assertListEqual(
               tokenizer.convert_tokens_to_ids(A		)	,      [4, 3_2, 1_1, 1_0, 1_2, 4, 1_0, 1_2, 4, 7, 4, 6, 5, 1_2, 6]	,      )

           _UpperCAmelCase     :      str														=       tokenizer.tokenize("I was born in 92000, and this is falsé."		)
           self.assertListEqual(
               A	,      [SPIECE_UNDERLINE, "I", SPIECE_UNDERLINE, "w", "a", "s", SPIECE_UNDERLINE, "b", "o", "r", "n", SPIECE_UNDERLINE, "i", "n", SPIECE_UNDERLINE, "92000", ",", SPIECE_UNDERLINE, "a", "n", "d", SPIECE_UNDERLINE, "t", "h", "i", "s", SPIECE_UNDERLINE, "i", "s", SPIECE_UNDERLINE, "f", "a", "l", "s", "é", "."]		)

           _UpperCAmelCase     :      int														=       tokenizer.convert_tokens_to_ids(A		)
           # fmt: off
           self.assertListEqual(A	,      [4, 3_0, 4, 2_0, 7, 1_2, 4, 2_5, 8, 1_3, 9, 4, 1_0, 9, 4, 3, 2_3, 4, 7, 9, 1_4, 4, 6, 1_1, 1_0, 1_2, 4, 1_0, 1_2, 4, 1_9, 7, 1_5, 1_2, 7_3, 2_6]		)
           # fmt: on

           _UpperCAmelCase     :      Optional[int]														=       tokenizer.convert_ids_to_tokens(A		)
           self.assertListEqual(
               A	,      [SPIECE_UNDERLINE, "I", SPIECE_UNDERLINE, "w", "a", "s", SPIECE_UNDERLINE, "b", "o", "r", "n", SPIECE_UNDERLINE, "i", "n", SPIECE_UNDERLINE, "<unk>", ",", SPIECE_UNDERLINE, "a", "n", "d", SPIECE_UNDERLINE, "t", "h", "i", "s", SPIECE_UNDERLINE, "i", "s", SPIECE_UNDERLINE, "f", "a", "l", "s", "é", "."]		)



      @slow
      def 		snake_case_   (	self	:      Any		):
           # Use custom sequence because this tokenizer does not handle numbers.
           _UpperCAmelCase     :      Any														=       [
               "Transformers (formerly known as pytorch-transformers and pytorch-pretrained-bert) provides "
               "general-purpose architectures (BERT, GPT, RoBERTa, XLM, DistilBert, XLNet...) for Natural "
               "Language Understanding (NLU) and Natural Language Generation (NLG) with over thirty-two pretrained "
               "models in one hundred plus languages and deep interoperability between Jax, PyTorch and TensorFlow.",
               "BERT is designed to pre-train deep bidirectional representations from unlabeled text by jointly "
               "conditioning on both left and right context in all layers.",
               "The quick brown fox jumps over the lazy dog.",
           ]

           # fmt: off
           _UpperCAmelCase     :      Dict														=       {
               "input_ids": [
                   [4, 3_2, 1_3, 7, 9, 1_2, 1_9, 8, 1_3, 1_8, 5, 1_3, 1_2, 4, 6_4, 1_9, 8, 1_3, 1_8, 5, 1_3, 1_5, 2_2, 4, 2_8, 9, 8, 2_0, 9, 4, 7, 1_2, 4, 2_4, 2_2, 6, 8, 1_3, 1_7, 1_1, 3_9, 6, 1_3, 7, 9, 1_2, 1_9, 8, 1_3, 1_8, 5, 1_3, 1_2, 4, 7, 9, 1_4, 4, 2_4, 2_2, 6, 8, 1_3, 1_7, 1_1, 3_9, 2_4, 1_3, 5, 6, 1_3, 7, 1_0, 9, 5, 1_4, 3_9, 2_5, 5, 1_3, 6, 6_3, 4, 2_4, 1_3, 8, 2_7, 1_0, 1_4, 5, 1_2, 4, 2_1, 5, 9, 5, 1_3, 7, 1_5, 3_9, 2_4, 1_6, 1_3, 2_4, 8, 1_2, 5, 4, 7, 1_3, 1_7, 1_1, 1_0, 6, 5, 1_7, 6, 1_6, 1_3, 5, 1_2, 4, 6_4, 4_0, 4_7, 5_4, 3_2, 2_3, 4, 5_3, 4_9, 3_2, 2_3, 4, 5_4, 8, 4_0, 4_7, 5_4, 3_2, 7, 2_3, 4, 6_9, 5_2, 4_3, 2_3, 4, 5_1, 1_0, 1_2, 6, 1_0, 1_5, 4_0, 5, 1_3, 6, 2_3, 4, 6_9, 5_2, 4_8, 5, 6, 2_6, 2_6, 2_6, 6_3, 4, 1_9, 8, 1_3, 4, 4_8, 7, 6, 1_6, 1_3, 7, 1_5, 4, 5_2, 7, 9, 2_1, 1_6, 7, 2_1, 5, 4, 6_1, 9, 1_4, 5, 1_3, 1_2, 6, 7, 9, 1_4, 1_0, 9, 2_1, 4, 6_4, 4_8, 5_2, 6_1, 6_3, 4, 7, 9, 1_4, 4, 4_8, 7, 6, 1_6, 1_3, 7, 1_5, 4, 5_2, 7, 9, 2_1, 1_6, 7, 2_1, 5, 4, 5_3, 5, 9, 5, 1_3, 7, 6, 1_0, 8, 9, 4, 6_4, 4_8, 5_2, 5_3, 6_3, 4, 2_0, 1_0, 6, 1_1, 4, 8, 2_7, 5, 1_3, 4, 6, 1_1, 1_0, 1_3, 6, 2_2, 3_9, 6, 2_0, 8, 4, 2_4, 1_3, 5, 6, 1_3, 7, 1_0, 9, 5, 1_4, 4, 1_8, 8, 1_4, 5, 1_5, 1_2, 4, 1_0, 9, 4, 8, 9, 5, 4, 1_1, 1_6, 9, 1_4, 1_3, 5, 1_4, 4, 2_4, 1_5, 1_6, 1_2, 4, 1_5, 7, 9, 2_1, 1_6, 7, 2_1, 5, 1_2, 4, 7, 9, 1_4, 4, 1_4, 5, 5, 2_4, 4, 1_0, 9, 6, 5, 1_3, 8, 2_4, 5, 1_3, 7, 2_5, 1_0, 1_5, 1_0, 6, 2_2, 4, 2_5, 5, 6, 2_0, 5, 5, 9, 4, 5_8, 7, 3_7, 2_3, 4, 4_9, 2_2, 3_2, 8, 1_3, 1_7, 1_1, 4, 7, 9, 1_4, 4, 3_2, 5, 9, 1_2, 8, 1_3, 5_5, 1_5, 8, 2_0, 2_6, 2],
                   [4, 4_0, 4_7, 5_4, 3_2, 4, 1_0, 1_2, 4, 1_4, 5, 1_2, 1_0, 2_1, 9, 5, 1_4, 4, 6, 8, 4, 2_4, 1_3, 5, 3_9, 6, 1_3, 7, 1_0, 9, 4, 1_4, 5, 5, 2_4, 4, 2_5, 1_0, 1_4, 1_0, 1_3, 5, 1_7, 6, 1_0, 8, 9, 7, 1_5, 4, 1_3, 5, 2_4, 1_3, 5, 1_2, 5, 9, 6, 7, 6, 1_0, 8, 9, 1_2, 4, 1_9, 1_3, 8, 1_8, 4, 1_6, 9, 1_5, 7, 2_5, 5, 1_5, 5, 1_4, 4, 6, 5, 3_7, 6, 4, 2_5, 2_2, 4, 4_6, 8, 1_0, 9, 6, 1_5, 2_2, 4, 1_7, 8, 9, 1_4, 1_0, 6, 1_0, 8, 9, 1_0, 9, 2_1, 4, 8, 9, 4, 2_5, 8, 6, 1_1, 4, 1_5, 5, 1_9, 6, 4, 7, 9, 1_4, 4, 1_3, 1_0, 2_1, 1_1, 6, 4, 1_7, 8, 9, 6, 5, 3_7, 6, 4, 1_0, 9, 4, 7, 1_5, 1_5, 4, 1_5, 7, 2_2, 5, 1_3, 1_2, 2_6, 2, 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, 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],
                   [4, 3_2, 1_1, 5, 4, 4_5, 1_6, 1_0, 1_7, 2_8, 4, 2_5, 1_3, 8, 2_0, 9, 4, 1_9, 8, 3_7, 4, 4_6, 1_6, 1_8, 2_4, 1_2, 4, 8, 2_7, 5, 1_3, 4, 6, 1_1, 5, 4, 1_5, 7, 5_7, 2_2, 4, 1_4, 8, 2_1, 2_6, 2, 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, 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, 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],
               ],
               "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, 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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
               ]
           }
           # fmt: on

           self.tokenizer_integration_test_util(
               expected_encoding=A	,      model_name="microsoft/speecht5_asr"	,      revision="c5ef64c71905caeccde0e4462ef3f9077224c524"	,      sequences=A	,      )





"""simple docstring"""




import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
 from transformers.models.mobilevitva.modeling_mobilevitva import (
     MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
     make_divisible,
 )


if is_vision_available():
 from PIL import Image

 from transformers import MobileViTImageProcessor






class       UpperCAmelCase_    (							_UpperCamelCase		):



      def 		snake_case_   (	self	:      str		):
           _UpperCAmelCase     :      Dict														=       self.config_class(**self.inputs_dict		)
           self.parent.assertTrue(hasattr(A	,      "width_multiplier"		)		)







class       UpperCAmelCase_    :



      def __init__(	self	:      Dict	,      A	:      Union[str, Any]	,      A	:      Dict=1_3	,      A	:      Union[str, Any]=6_4	,      A	:      int=2	,      A	:      Tuple=3	,      A	:      int="swish"	,      A	:      Optional[int]=3	,      A	:      Tuple=3_2	,      A	:      Tuple=0.1	,      A	:      List[Any]=0.02	,      A	:      Dict=True	,      A	:      str=True	,      A	:      Any=1_0	,      A	:      Optional[int]=None	,      A	:      int=0.25	,      A	:      int=0.0	,      A	:      Dict=0.0	,      ):
           _UpperCAmelCase     :      List[Any]														=       parent
           _UpperCAmelCase     :      Optional[Any]														=       batch_size
           _UpperCAmelCase     :      Dict														=       image_size
           _UpperCAmelCase     :      int														=       patch_size
           _UpperCAmelCase     :      List[str]														=       num_channels
           _UpperCAmelCase     :      Optional[int]														=       make_divisible(5_1_2 * width_multiplier	,      divisor=8		)
           _UpperCAmelCase     :      Dict														=       hidden_act
           _UpperCAmelCase     :      List[str]														=       conv_kernel_size
           _UpperCAmelCase     :      Optional[int]														=       output_stride
           _UpperCAmelCase     :      Union[str, Any]														=       classifier_dropout_prob
           _UpperCAmelCase     :      str														=       use_labels
           _UpperCAmelCase     :      Dict														=       is_training
           _UpperCAmelCase     :      Optional[int]														=       num_labels
           _UpperCAmelCase     :      Tuple														=       initializer_range
           _UpperCAmelCase     :      Tuple														=       scope
           _UpperCAmelCase     :      List[Any]														=       width_multiplier
           _UpperCAmelCase     :      List[str]														=       ffn_dropout
           _UpperCAmelCase     :      List[Any]														=       attn_dropout



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      Optional[Any]														=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

           _UpperCAmelCase     :      str														=       None
           _UpperCAmelCase     :      List[Any]														=       None
           if self.use_labels:
                _UpperCAmelCase     :      Dict														=       ids_tensor([self.batch_size]	,      self.num_labels		)
                _UpperCAmelCase     :      List[Any]														=       ids_tensor([self.batch_size, self.image_size, self.image_size]	,      self.num_labels		)

           _UpperCAmelCase     :      Optional[int]														=       self.get_config()

           return config, pixel_values, labels, pixel_labels



      def 		snake_case_   (	self	:      List[Any]		):
           return MobileViTVaConfig(
               image_size=self.image_size	,      patch_size=self.patch_size	,      num_channels=self.num_channels	,      hidden_act=self.hidden_act	,      conv_kernel_size=self.conv_kernel_size	,      output_stride=self.output_stride	,      classifier_dropout_prob=self.classifier_dropout_prob	,      initializer_range=self.initializer_range	,      width_multiplier=self.width_multiplier	,      ffn_dropout=self.ffn_dropout_prob	,      attn_dropout=self.attn_dropout_prob	,      )



      def 		snake_case_   (	self	:      int	,      A	:      Optional[Any]	,      A	:      Optional[int]	,      A	:      Any	,      A	:      int		):
           _UpperCAmelCase     :      List[str]														=       MobileViTVaModel(config=A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      str														=       model(A		)
           self.parent.assertEqual(
               result.last_hidden_state.shape	,      (
                   self.batch_size,
                   self.last_hidden_size,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )



      def 		snake_case_   (	self	:      Any	,      A	:      Optional[int]	,      A	:      Optional[Any]	,      A	:      str	,      A	:      List[str]		):
           _UpperCAmelCase     :      List[str]														=       self.num_labels
           _UpperCAmelCase     :      int														=       MobileViTVaForImageClassification(A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      str														=       model(A	,      labels=A		)
           self.parent.assertEqual(result.logits.shape	,      (self.batch_size, self.num_labels)		)



      def 		snake_case_   (	self	:      Optional[int]	,      A	:      Tuple	,      A	:      Any	,      A	:      Any	,      A	:      Optional[Any]		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.num_labels
           _UpperCAmelCase     :      Optional[int]														=       MobileViTVaForSemanticSegmentation(A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      List[str]														=       model(A		)
           self.parent.assertEqual(
               result.logits.shape	,      (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )
           _UpperCAmelCase     :      Optional[int]														=       model(A	,      labels=A		)
           self.parent.assertEqual(
               result.logits.shape	,      (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )



      def 		snake_case_   (	self	:      Any		):
           _UpperCAmelCase     :      Any														=       self.prepare_config_and_inputs()
           _UpperCAmelCase							,			_UpperCAmelCase							,			_UpperCAmelCase							,			_UpperCAmelCase     :      str														=       config_and_inputs
           _UpperCAmelCase     :      str														=       {"pixel_values": pixel_values}
           return config, inputs_dict







@require_torch
class       UpperCAmelCase_    (							_UpperCamelCase			,     _UpperCamelCase			,     unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:  Tuple						=					(
          (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
          if is_torch_available()
          else ()
      )

      __SCREAMING_SNAKE_CASE		:  Optional[Any]						=					(
          {
              'feature-extraction': MobileViTVaModel,
              'image-classification': MobileViTVaForImageClassification,
              'image-segmentation': MobileViTVaForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      __SCREAMING_SNAKE_CASE		:  str						=					False
      __SCREAMING_SNAKE_CASE		:  List[Any]						=					False
      __SCREAMING_SNAKE_CASE		:  Dict						=					False
      __SCREAMING_SNAKE_CASE		:  Union[str, Any]						=					False



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      Dict														=       MobileViTVaModelTester(self		)
           _UpperCAmelCase     :      Optional[Any]														=       MobileViTVaConfigTester(self	,      config_class=A	,      has_text_modality=A		)



      def 		snake_case_   (	self	:      int		):
           self.config_tester.run_common_tests()



      @unittest.skip(reason="MobileViTV2 does not use inputs_embeds"		)
      def 		snake_case_   (	self	:      Optional[int]		):
           pass



      @unittest.skip(reason="MobileViTV2 does not support input and output embeddings"		)
      def 		snake_case_   (	self	:      Optional[Any]		):
           pass



      @unittest.skip(reason="MobileViTV2 does not output attentions"		)
      def 		snake_case_   (	self	:      int		):
           pass



      @require_torch_multi_gpu
      @unittest.skip(reason="Got `CUDA error: misaligned address` for tests after this one being run."		)
      def 		snake_case_   (	self	:      Any		):
           pass



      @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
      def 		snake_case_   (	self	:      str		):
           pass



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase							,			_UpperCAmelCase     :      Optional[Any]														=       self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                _UpperCAmelCase     :      Union[str, Any]														=       model_class(A		)
                _UpperCAmelCase     :      str														=       inspect.signature(model.forward		)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                _UpperCAmelCase     :      int														=       [*signature.parameters.keys()]

                _UpperCAmelCase     :      Optional[Any]														=       ["pixel_values"]
                self.assertListEqual(arg_names[:1]	,      A		)



      def 		snake_case_   (	self	:      int		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*A		)



      def 		snake_case_   (	self	:      Optional[Any]		):
           def check_hidden_states_output(A	:      Union[str, Any]	,      A	:      Dict	,      A	:      str		):
                _UpperCAmelCase     :      int														=       model_class(A		)
                model.to(A		)
                model.eval()

                with torch.no_grad():
                     _UpperCAmelCase     :      Tuple														=       model(**self._prepare_for_class(A	,      A		)		)

                _UpperCAmelCase     :      List[str]														=       outputs.hidden_states

                _UpperCAmelCase     :      int														=       5
                self.assertEqual(len(A		)	,      A		)

                # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
                # with the width and height being successively divided by 2.
                _UpperCAmelCase     :      Optional[int]														=       2
                for i in range(len(A		)		):
                     self.assertListEqual(
                         list(hidden_states[i].shape[-2:]		)	,      [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]	,      )
                     divisor *= 2

                self.assertEqual(self.model_tester.output_stride	,      divisor // 2		)

           _UpperCAmelCase							,			_UpperCAmelCase     :      List[Any]														=       self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                _UpperCAmelCase     :      Optional[Any]														=       True
                check_hidden_states_output(A	,      A	,      A		)

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                _UpperCAmelCase     :      str														=       True

                check_hidden_states_output(A	,      A	,      A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      List[str]														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      int														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*A		)



      @slow
      def 		snake_case_   (	self	:      int		):
           for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _UpperCAmelCase     :      Union[str, Any]														=       MobileViTVaModel.from_pretrained(A		)
                self.assertIsNotNone(A		)







def 		__snake_case		( )    ->  Optional[Any]:





     '''simple docstring'''

     _UpperCAmelCase     :      Any														=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
     return image






@require_torch
@require_vision
class       UpperCAmelCase_    (							unittest.TestCase		):



      @cached_property
      def 		snake_case_   (	self	:      Any		):
           return (
               MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"		)
               if is_vision_available()
               else None
           )



      @slow
      def 		snake_case_   (	self	:      Dict		):
           _UpperCAmelCase     :      Dict														=       MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"		).to(
               A		)

           _UpperCAmelCase     :      Optional[Any]														=       self.default_image_processor
           _UpperCAmelCase     :      Tuple														=       prepare_img()
           _UpperCAmelCase     :      Union[str, Any]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      Tuple														=       model(**A		)

           # verify the logits
           _UpperCAmelCase     :      Tuple														=       torch.Size((1, 1_0_0_0)		)
           self.assertEqual(outputs.logits.shape	,      A		)

           _UpperCAmelCase     :      Optional[Any]														=       torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]		).to(A		)

           self.assertTrue(torch.allclose(outputs.logits[0, :3]	,      A	,      atol=1e-4		)		)



      @slow
      def 		snake_case_   (	self	:      Optional[int]		):
           _UpperCAmelCase     :      List[Any]														=       MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)
           _UpperCAmelCase     :      Any														=       model.to(A		)

           _UpperCAmelCase     :      Optional[Any]														=       MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)

           _UpperCAmelCase     :      Dict														=       prepare_img()
           _UpperCAmelCase     :      Union[str, Any]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      int														=       model(**A		)
           _UpperCAmelCase     :      Any														=       outputs.logits

           # verify the logits
           _UpperCAmelCase     :      Optional[int]														=       torch.Size((1, 2_1, 3_2, 3_2)		)
           self.assertEqual(logits.shape	,      A		)

           _UpperCAmelCase     :      Union[str, Any]														=       torch.tensor(
               [
                   [[7.0_863, 7.1_525, 6.8_201], [6.6_931, 6.8_770, 6.8_933], [6.2_978, 7.0_366, 6.9_636]],
                   [[-3.7_134, -3.6_712, -3.6_675], [-3.5_825, -3.3_549, -3.4_777], [-3.3_435, -3.3_979, -3.2_857]],
                   [[-2.9_329, -2.8_003, -2.7_369], [-3.0_564, -2.4_780, -2.0_207], [-2.6_889, -1.9_298, -1.7_640]],
               ]	,      device=A	,      )

           self.assertTrue(torch.allclose(logits[0, :3, :3, :3]	,      A	,      atol=1e-4		)		)



      @slow
      def 		snake_case_   (	self	:      List[str]		):
           _UpperCAmelCase     :      List[str]														=       MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)
           _UpperCAmelCase     :      Tuple														=       model.to(A		)

           _UpperCAmelCase     :      Dict														=       MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)

           _UpperCAmelCase     :      Optional[int]														=       prepare_img()
           _UpperCAmelCase     :      Optional[int]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      Tuple														=       model(**A		)

           _UpperCAmelCase     :      Optional[int]														=       outputs.logits.detach().cpu()

           _UpperCAmelCase     :      List[Any]														=       image_processor.post_process_semantic_segmentation(outputs=A	,      target_sizes=[(5_0, 6_0)]		)
           _UpperCAmelCase     :      Dict														=       torch.Size((5_0, 6_0)		)
           self.assertEqual(segmentation[0].shape	,      A		)

           _UpperCAmelCase     :      Dict														=       image_processor.post_process_semantic_segmentation(outputs=A		)
           _UpperCAmelCase     :      Union[str, Any]														=       torch.Size((3_2, 3_2)		)
           self.assertEqual(segmentation[0].shape	,      A		)
