
import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_A						      =				get_tests_dir("fixtures/test_sentencepiece_with_bytefallback.model")







@require_sentencepiece
@require_tokenizers
class   lowerCamelCase	(						_A							,				unittest.TestCase						):
     UpperCAmelCase__       :							List[Any]     =	GPTSwaTokenizer
     UpperCAmelCase__       :							Any     =	False
     UpperCAmelCase__       :							List[Any]     =	True
     UpperCAmelCase__       :							Any     =	False





     def 	UpperCAmelCase(self   :					Dict     )		->		Tuple:
         super().setUp()

         # We have a SentencePiece fixture for testing
         snake_case				  =      GPTSwaTokenizer(__lowerCamelCase       ,					eos_token="<unk>"       ,					bos_token="<unk>"       ,					pad_token="<unk>"     )

         tokenizer.save_pretrained(self.tmpdirname     )





     def 	UpperCAmelCase(self   :					Any       ,					_A   :					Optional[Any]     )		->		Optional[Any]:
         snake_case				  =      "This is a test"
         snake_case				  =      "This is a test"
         return input_text, output_text





     def 	UpperCAmelCase(self   :					List[str]     )		->		Union[str, Any]:
         snake_case				  =      "<s>"
         snake_case				  =      1

         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   :					List[Any]     )		->		Optional[int]:
         snake_case				  =      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(__lowerCamelCase     )       ,					2_0_0_0     )





     def 	UpperCAmelCase(self   :					List[Any]     )		->		str:
         self.assertEqual(self.get_tokenizer().vocab_size       ,					2_0_0_0     )





     def 	UpperCAmelCase(self   :					Optional[int]     )		->		Any:
         snake_case				  =      GPTSwaTokenizer(__lowerCamelCase     )

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

         self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCamelCase     )       ,					[4_6_5, 2_8_7, 2_6_5, 6_3_1, 8_4_2]     )

         snake_case				  =      tokenizer.tokenize("I was born in 92000, and this is falsé."     )
         # fmt: off
         self.assertListEqual(
             __lowerCamelCase       ,					["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]       ,					)
         # fmt: on

         snake_case				  =      tokenizer.convert_tokens_to_ids(__lowerCamelCase     )
         self.assertListEqual(
             __lowerCamelCase       ,					[2_6_2, 2_7_2, 1_5_2_5, 2_8_6, 2_7_1, 2_6_8, 6_0, 9_1_6, 6_3_3, 6_3_3, 6_3_3, 2_5_9, 2_6_6, 3_0_1, 2_8_7, 3_8_4, 3_6_7, 2_6_3, 1_9_8, 1_7_2, 2_6_0]       ,					)

         snake_case				  =      tokenizer.convert_ids_to_tokens(__lowerCamelCase     )
         # fmt: off
         self.assertListEqual(
             __lowerCamelCase       ,					["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]     )
         # fmt: on





     def 	UpperCAmelCase(self   :					Dict     )		->		Tuple:
         snake_case				  =      GPTSwaTokenizer(__lowerCamelCase     )
         snake_case				  =      ["This is a test", "I was born in 92000, and this is falsé."]
         snake_case				  =      [
             [4_6_5, 2_8_7, 2_6_5, 6_3_1, 8_4_2],
             [2_6_2, 2_7_2, 1_5_2_5, 2_8_6, 2_7_1, 2_6_8, 6_0, 9_1_6, 6_3_3, 6_3_3, 6_3_3, 2_5_9, 2_6_6, 3_0_1, 2_8_7, 3_8_4, 3_6_7, 2_6_3, 1_9_8, 1_7_2, 2_6_0],
         ]

         # Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
         for text, expected_ids in zip(__lowerCamelCase       ,					__lowerCamelCase     ):
             self.assertListEqual(tokenizer.encode_fast(__lowerCamelCase     )       ,					__lowerCamelCase     )

         # Test that decode_fast returns the input text
         for text, token_ids in zip(__lowerCamelCase       ,					__lowerCamelCase     ):
             self.assertEqual(tokenizer.decode_fast(__lowerCamelCase     )       ,					__lowerCamelCase     )





     @slow
     def 	UpperCAmelCase(self   :					int     )		->		Any:
         snake_case				  =      [
             "<|python|>def fibonacci(n)\n    if n < 0:\n        print('Incorrect input')",
             "Hey there, how are you doing this fine day?",
             "This is a text with a trailing spaces followed by a dot     .",
             "Häj sväjs lillebrör! =)",
             "Det är inget fel på Mr. Cool",
         ]

         # fmt: off
         snake_case				  =      {"input_ids": [[6_3_4_2_3, 5, 6_8_1_1, 1_4_9_5_4, 2_8_2, 8_1_6, 3_8_2_1, 6_3_4_6_6, 6_3_4_2_5, 6_3_4_6_2, 1_8, 6_3_9_7_8, 6_7_8, 3_0_1, 1_3_2_0, 6_3_4_2_3, 6_3_4_5_5, 6_3_4_5_8, 1_8, 6_3_9_8_2, 4_2_4_6, 3_9_4_0, 1_9_0_1, 4_7_7_8_9, 5_5_4_7, 1_8_9_9_4], [1_9_6_3_0, 1_1_0_0, 6_3_4_4_6, 1_3_4_2, 6_3_3, 5_4_4, 4_4_8_8, 5_9_3, 5_1_0_2, 2_4_1_6, 6_3_4_9_5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_6_5_2, 4_2_8, 2_6_8, 1_9_3_6, 5_1_5, 2_6_8, 5_8_5_9_3, 2_2_4_1_3, 9_1_0_6, 5_4_6, 2_6_8, 3_3_2_1_3, 6_3_9_7_9, 6_9_8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_5_1_3_0, 6_3_4_5_0, 9_2_4, 6_3_4_4_9, 2_2_4_9, 4_0_6_2, 1_5_5_8, 3_1_8, 6_3_5_0_4, 2_1_4_9_8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_0_9, 3_7_7, 2_8_2_7, 2_5_5_9, 3_3_2, 6_5_7_5, 6_3_4_4_3, 2_6_8_0_1, 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]], "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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [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], [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]]}
         # fmt: on
         self.tokenizer_integration_test_util(
             expected_encoding=__lowerCamelCase       ,					model_name="AI-Sweden/gpt-sw3-126m"       ,					sequences=__lowerCamelCase       ,					)



from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_A						      =				logging.get_logger(__name__)

_A						      =				{
    "sail/poolformer_s12": "https://huggingface.co/sail/poolformer_s12/resolve/main/config.json",
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
}







class   lowerCamelCase	(						A_						):
     UpperCAmelCase__       :							Any     =	"poolformer"





     def __init__(self   :					Optional[int]       ,					_A   :					Optional[Any]=3       ,					_A   :					Optional[int]=1_6       ,					_A   :					Dict=1_6       ,					_A   :					Tuple=3       ,					_A   :					Tuple=4.0       ,					_A   :					int=[2, 2, 6, 2]       ,					_A   :					Dict=[6_4, 1_2_8, 3_2_0, 5_1_2]       ,					_A   :					int=[7, 3, 3, 3]       ,					_A   :					List[str]=[4, 2, 2, 2]       ,					_A   :					str=[2, 1, 1, 1]       ,					_A   :					List[Any]=4       ,					_A   :					Any=0.0       ,					_A   :					Optional[Any]="gelu"       ,					_A   :					Optional[Any]=True       ,					_A   :					List[str]=1E-5       ,					_A   :					List[str]=0.02       ,					**_A   :					str       ,					)		->		Tuple:
         snake_case				  =      num_channels
         snake_case				  =      patch_size
         snake_case				  =      stride
         snake_case				  =      padding
         snake_case				  =      pool_size
         snake_case				  =      hidden_sizes
         snake_case				  =      mlp_ratio
         snake_case				  =      depths
         snake_case				  =      patch_sizes
         snake_case				  =      strides
         snake_case				  =      num_encoder_blocks
         snake_case				  =      drop_path_rate
         snake_case				  =      hidden_act
         snake_case				  =      use_layer_scale
         snake_case				  =      layer_scale_init_value
         snake_case				  =      initializer_range
         super().__init__(**_A     )







class   lowerCamelCase	(						A_						):
     UpperCAmelCase__       :							Tuple     =	version.parse("1.11"						)





     @property
     def 	UpperCAmelCase(self   :					int     )		->		Mapping[str, Mapping[int, str]]:
         return OrderedDict(
             [
                 ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
             ]     )





     @property
     def 	UpperCAmelCase(self   :					int     )		->		float:
         return 2E-3

