


import flax.linen as nn
import jax
import jax.numpy as jnp




class A    (  nn.Module	):
      UpperCamelCase__				:    int
      UpperCamelCase__				:    jnp.dtype =jnp.floataa






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						List[str]            =nn.Conv(
                 self.out_channels     ,  kernel_size=(3, 3)     ,  strides=(1, 1)     ,  padding=((1, 1), (1, 1))     ,  dtype=self.dtype     ,  )






      def __call__(   self		:	int     ,  lowercase_		:	Tuple					)   ->		int:
             """simple docstring"""




             _lowerCamelCase      ,	_lowerCamelCase      ,	_lowerCamelCase      ,	_lowerCamelCase			:						Optional[Any]            =hidden_states.shape
             _lowerCamelCase			:						Optional[int]            =jax.image.resize(
                 lowercase_     ,  shape=(batch, height * 2, width * 2, channels)     ,  method='nearest'     ,  )
             _lowerCamelCase			:						Dict            =self.conv(lowercase_					)
             return hidden_states




class A    (  nn.Module	):
      UpperCamelCase__				:    int
      UpperCamelCase__				:    jnp.dtype =jnp.floataa






      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            =nn.Conv(
                 self.out_channels     ,  kernel_size=(3, 3)     ,  strides=(2, 2)     ,  padding=((1, 1), (1, 1))     ,  dtype=self.dtype     ,  )






      def __call__(   self		:	Tuple     ,  lowercase_		:	int					)   ->		List[str]:
             """simple docstring"""




             _lowerCamelCase			:						str            =self.conv(lowercase_					)
             return hidden_states




class A    (  nn.Module	):
      UpperCamelCase__				:    int
      UpperCamelCase__				:    int =None
      UpperCamelCase__				:    float =0.0
      UpperCamelCase__				:    bool =None
      UpperCamelCase__				:    jnp.dtype =jnp.floataa






      def 			lowerCamelCase			(   self		:	int					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            =self.in_channels if self.out_channels is None else self.out_channels

             _lowerCamelCase			:						List[Any]            =nn.GroupNorm(num_groups=32     ,  epsilon=1E-5					)
             _lowerCamelCase			:						Union[str, Any]            =nn.Conv(
                 lowercase_     ,  kernel_size=(3, 3)     ,  strides=(1, 1)     ,  padding=((1, 1), (1, 1))     ,  dtype=self.dtype     ,  )

             _lowerCamelCase			:						Optional[Any]            =nn.Dense(lowercase_     ,  dtype=self.dtype					)

             _lowerCamelCase			:						int            =nn.GroupNorm(num_groups=32     ,  epsilon=1E-5					)
             _lowerCamelCase			:						Optional[Any]            =nn.Dropout(self.dropout_prob					)
             _lowerCamelCase			:						Any            =nn.Conv(
                 lowercase_     ,  kernel_size=(3, 3)     ,  strides=(1, 1)     ,  padding=((1, 1), (1, 1))     ,  dtype=self.dtype     ,  )

             _lowerCamelCase			:						str            =self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

             _lowerCamelCase			:						Tuple            =None
             if use_nin_shortcut:
                    _lowerCamelCase			:						Any            =nn.Conv(
                        lowercase_     ,  kernel_size=(1, 1)     ,  strides=(1, 1)     ,  padding='VALID'     ,  dtype=self.dtype     ,  )






      def __call__(   self		:	Any     ,  lowercase_		:	List[str]     ,  lowercase_		:	Optional[int]     ,  lowercase_		:	Dict=True					)   ->		Dict:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            =hidden_states
             _lowerCamelCase			:						Optional[int]            =self.norma(lowercase_					)
             _lowerCamelCase			:						str            =nn.swish(lowercase_					)
             _lowerCamelCase			:						Optional[int]            =self.conva(lowercase_					)

             _lowerCamelCase			:						Tuple            =self.time_emb_proj(nn.swish(lowercase_					)					)
             _lowerCamelCase			:						Optional[int]            =jnp.expand_dims(jnp.expand_dims(lowercase_     ,  1					)     ,  1					)
             _lowerCamelCase			:						List[str]            =hidden_states + temb

             _lowerCamelCase			:						Optional[int]            =self.norma(lowercase_					)
             _lowerCamelCase			:						Optional[int]            =nn.swish(lowercase_					)
             _lowerCamelCase			:						List[str]            =self.dropout(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =self.conva(lowercase_					)

             if self.conv_shortcut is not None:
                    _lowerCamelCase			:						Dict            =self.conv_shortcut(lowercase_					)

             return hidden_states + residual






import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XLMRobertaTokenizer, XLMRobertaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase		   =			get_tests_dir('fixtures/test_sentencepiece.model')




@require_sentencepiece
@require_tokenizers
class A    (  UpperCamelCase_       ,				unittest.TestCase	):
      UpperCamelCase__				:    List[Any] =XLMRobertaTokenizer
      UpperCamelCase__				:    Union[str, Any] =XLMRobertaTokenizerFast
      UpperCamelCase__				:    int =True
      UpperCamelCase__				:    Optional[Any] =True






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Dict:
             """simple docstring"""




             super().setUp()

             # We have a SentencePiece fixture for testing
             _lowerCamelCase			:						Dict            =XLMRobertaTokenizer(lowercase_     ,  keep_accents=lowercase_					)
             tokenizer.save_pretrained(self.tmpdirname					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Any:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            ='<pad>'
             _lowerCamelCase			:						Optional[int]            =1

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






      def 			lowerCamelCase			(   self		:	Any					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						str            =list(self.get_tokenizer().get_vocab().keys()					)

             self.assertEqual(vocab_keys[0]     ,  '<s>'					)
             self.assertEqual(vocab_keys[1]     ,  '<pad>'					)
             self.assertEqual(vocab_keys[-1]     ,  '<mask>'					)
             self.assertEqual(len(lowercase_					)     ,  1002					)






      def 			lowerCamelCase			(   self		:	int					)   ->		Optional[Any]:
             """simple docstring"""




             self.assertEqual(self.get_tokenizer().vocab_size     ,  1002					)






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            =XLMRobertaTokenizer(lowercase_     ,  keep_accents=lowercase_					)

             _lowerCamelCase			:						List[Any]            =tokenizer.tokenize('This is a test'					)
             self.assertListEqual(lowercase_     ,  ['▁This', '▁is', '▁a', '▁t', 'est']					)

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(lowercase_					)     ,  [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]     ,  )

             _lowerCamelCase			:						int            =tokenizer.tokenize('I was born in 92000, and this is falsé.'					)
             self.assertListEqual(
                 lowercase_     ,  [
                     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			:						Optional[Any]            =tokenizer.convert_tokens_to_ids(lowercase_					)
             self.assertListEqual(
                 lowercase_     ,  [
                     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]
                     #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
                 ]     ,  )

             _lowerCamelCase			:						Optional[Any]            =tokenizer.convert_ids_to_tokens(lowercase_					)
             self.assertListEqual(
                 lowercase_     ,  [
                     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 			lowerCamelCase			(   self		:	List[Any]					)   ->		Any:
             """simple docstring"""




             if not self.test_slow_tokenizer:
                    # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                    return

             _lowerCamelCase			:						List[str]            =(self.rust_tokenizer_class, 'hf-internal-testing/tiny-xlm-roberta', {})
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
                           _lowerCamelCase			:						int            =self.rust_tokenizer_class.from_pretrained(lowercase_     ,  **lowercase_					)
                           _lowerCamelCase			:						List[Any]            =self.tokenizer_class.from_pretrained(lowercase_     ,  **lowercase_					)

                           _lowerCamelCase			:						int            =tempfile.mkdtemp()

                           _lowerCamelCase			:						List[str]            =tokenizer_r.save_pretrained(lowercase_					)
                           _lowerCamelCase			:						int            =tokenizer_p.save_pretrained(lowercase_					)

                           # 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					)					)
                           _lowerCamelCase			:						Optional[Any]            =tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f					)
                           self.assertSequenceEqual(lowercase_     ,  lowercase_					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						int            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						Any            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)
                                  # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                                  # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                           shutil.rmtree(lowercase_					)

                           # Save tokenizer rust, legacy_format=True
                           _lowerCamelCase			:						Dict            =tempfile.mkdtemp()

                           _lowerCamelCase			:						int            =tokenizer_r.save_pretrained(lowercase_     ,  legacy_format=lowercase_					)
                           _lowerCamelCase			:						Optional[Any]            =tokenizer_p.save_pretrained(lowercase_					)

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

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						int            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[Any]            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)

                           shutil.rmtree(lowercase_					)

                           # Save tokenizer rust, legacy_format=False
                           _lowerCamelCase			:						str            =tempfile.mkdtemp()

                           _lowerCamelCase			:						Optional[Any]            =tokenizer_r.save_pretrained(lowercase_     ,  legacy_format=lowercase_					)
                           _lowerCamelCase			:						Any            =tokenizer_p.save_pretrained(lowercase_					)

                           # 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
                           _lowerCamelCase			:						str            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[str]            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)

                           shutil.rmtree(lowercase_					)






      @cached_property
      def 			lowerCamelCase			(   self		:	List[str]					)   ->		List[Any]:
             """simple docstring"""




             return XLMRobertaTokenizer.from_pretrained('xlm-roberta-base'					)






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Dict:
             """simple docstring"""




             with tempfile.NamedTemporaryFile() as f:
                    shutil.copyfile(lowercase_     ,  f.name					)
                    _lowerCamelCase			:						Union[str, Any]            =XLMRobertaTokenizer(f.name     ,  keep_accents=lowercase_					)
                    _lowerCamelCase			:						Dict            =pickle.dumps(lowercase_					)
             pickle.loads(lowercase_					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Union[str, Any]:
             """simple docstring"""




             if not self.test_rust_tokenizer:
                    return

             _lowerCamelCase			:						Any            =self.get_tokenizer()
             _lowerCamelCase			:						Optional[int]            =self.get_rust_tokenizer()

             _lowerCamelCase			:						Tuple            ='I was born in 92000, and this is falsé.'

             _lowerCamelCase			:						Any            =tokenizer.tokenize(lowercase_					)
             _lowerCamelCase			:						List[str]            =rust_tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						int            =tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             _lowerCamelCase			:						Union[str, Any]            =rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Dict            =self.get_rust_tokenizer()
             _lowerCamelCase			:						Optional[int]            =tokenizer.encode(lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =rust_tokenizer.encode(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)






      @slow
      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            ='Hello World!'
             _lowerCamelCase			:						Union[str, Any]            =[0, 3_5378, 6661, 38, 2]
             # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
             # xlmr.eval()
             # xlmr.encode(symbols)

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






      @slow
      def 			lowerCamelCase			(   self		:	Any					)   ->		int:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            =(
                 '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			:						List[str]            =[
                 0,
                 3293,
                 83,
                 10,
                 4552,
                 4989,
                 7986,
                 678,
                 10,
                 5915,
                 111,
                 17_9459,
                 12_4850,
                 4,
                 6044,
                 237,
                 12,
                 6,
                 5,
                 6,
                 4,
                 6780,
                 705,
                 15,
                 1388,
                 44,
                 378,
                 1_0114,
                 711,
                 152,
                 20,
                 6,
                 5,
                 2_2376,
                 642,
                 1221,
                 1_5190,
                 3_4153,
                 450,
                 5608,
                 959,
                 1119,
                 5_7702,
                 136,
                 186,
                 47,
                 1098,
                 2_9367,
                 47,
                 # 4426, # What fairseq tokenizes from "<unk>": "_<"
                 # 3678, # What fairseq tokenizes from "<unk>": "unk"
                 # 2740, # What fairseq tokenizes from "<unk>": ">"
                 3,  # What we tokenize from "<unk>": "<unk>"
                 6,  # Residue from the tokenization: an extra sentencepiece underline
                 4,
                 6044,
                 237,
                 6284,
                 5_0901,
                 528,
                 31,
                 90,
                 34,
                 927,
                 2,
             ]
             # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
             # xlmr.eval()
             # xlmr.encode(symbols)

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






      @slow
      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            ={'input_ids': [[0, 1_1062, 8_2772, 7, 15, 8_2772, 538, 5_1529, 237, 1_7198, 1290, 206, 9, 21_5175, 1314, 136, 1_7198, 1290, 206, 9, 5_6359, 42, 12_2009, 9, 1_6466, 16, 8_7344, 4537, 9, 4717, 7_8381, 6, 15_9958, 7, 15, 2_4480, 618, 4, 527, 2_2693, 5428, 4, 2777, 2_4480, 9874, 4, 4_3523, 594, 4, 803, 1_8392, 3_3189, 18, 4, 4_3523, 2_4447, 1_2399, 100, 2_4955, 8_3658, 9626, 14_4057, 15, 839, 2_2335, 16, 136, 2_4955, 8_3658, 8_3479, 15, 3_9102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 12_2009, 11_5774, 23, 805, 1328, 4_6876, 7, 136, 5_3894, 1940, 4_2227, 4_1159, 1_7721, 823, 425, 4, 2_7512, 9_8722, 206, 136, 5531, 4970, 919, 1_7336, 5, 2], [0, 2_0080, 618, 83, 8_2775, 47, 479, 9, 1517, 73, 5_3894, 333, 8_0581, 11_0117, 1_8811, 5256, 1295, 51, 15_2526, 297, 7986, 390, 12_4416, 538, 3_5431, 214, 98, 1_5044, 2_5737, 136, 7108, 4_3701, 23, 756, 13_5355, 7, 5, 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], [0, 581, 6_3773, 11_9455, 6, 14_7797, 8_8203, 7, 645, 70, 21, 3285, 1_0269, 5, 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]], '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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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=lowercase_     ,  model_name='xlm-roberta-base'     ,  revision='d9d8a8ea5eb94b1c6654ae9249df7793cd2933d3'     ,  )


