
from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFCvtForImageClassification, TFCvtModel
						from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor





class   UpperCamelCase_      (      __snake_case		):







						'''simple docstring'''



						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Any:
										lowercase         =      self.config_class(**self.inputs_dict     )
										self.parent.assertTrue(hasattr(lowerCAmelCase__		,    "embed_dim"     )     )
										self.parent.assertTrue(hasattr(lowerCAmelCase__		,    "num_heads"     )     )





class   UpperCamelCase_      :







						'''simple docstring'''



						def __init__(			self							:Dict		,    lowerCAmelCase__							:List[str]		,    lowerCAmelCase__							:List[Any]=13		,    lowerCAmelCase__							:Optional[int]=64		,    lowerCAmelCase__							:Optional[Any]=3		,    lowerCAmelCase__							:str=[16, 48, 96]		,    lowerCAmelCase__							:List[str]=[1, 3, 6]		,    lowerCAmelCase__							:Union[str, Any]=[1, 2, 10]		,    lowerCAmelCase__							:Optional[int]=[7, 3, 3]		,    lowerCAmelCase__							:Union[str, Any]=[4, 2, 2]		,    lowerCAmelCase__							:List[str]=[2, 1, 1]		,    lowerCAmelCase__							:int=[2, 2, 2]		,    lowerCAmelCase__							:List[str]=[False, False, True]		,    lowerCAmelCase__							:List[str]=[0.0, 0.0, 0.0]		,    lowerCAmelCase__							:Any=0.02		,    lowerCAmelCase__							:Optional[int]=1E-1_2		,    lowerCAmelCase__							:List[str]=True		,    lowerCAmelCase__							:Union[str, Any]=True		,    lowerCAmelCase__							:Optional[Any]=2		,    )  ->Optional[Any]:
										lowercase         =      parent
										lowercase         =      batch_size
										lowercase         =      image_size
										lowercase         =      patch_sizes
										lowercase         =      patch_stride
										lowercase         =      patch_padding
										lowercase         =      is_training
										lowercase         =      use_labels
										lowercase         =      num_labels
										lowercase         =      num_channels
										lowercase         =      embed_dim
										lowercase         =      num_heads
										lowercase         =      stride_kv
										lowercase         =      depth
										lowercase         =      cls_token
										lowercase         =      attention_drop_rate
										lowercase         =      initializer_range
										lowercase         =      layer_norm_eps





						def        SCREAMING_SNAKE_CASE(			self							:Tuple     )  ->Optional[int]:
										lowercase         =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

										lowercase         =      None
										if self.use_labels:
														# create a random int32 tensor of given shape
														lowercase         =      ids_tensor([self.batch_size]		,    self.num_labels     )

										lowercase         =      self.get_config()
										return config, pixel_values, labels





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->List[str]:
										return CvtConfig(
										    image_size=self.image_size		,    num_labels=self.num_labels		,    num_channels=self.num_channels		,    embed_dim=self.embed_dim		,    num_heads=self.num_heads		,    patch_sizes=self.patch_sizes		,    patch_padding=self.patch_padding		,    patch_stride=self.patch_stride		,    stride_kv=self.stride_kv		,    depth=self.depth		,    cls_token=self.cls_token		,    attention_drop_rate=self.attention_drop_rate		,    initializer_range=self.initializer_range		,    )





						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]		,    lowerCAmelCase__							:List[str]		,    lowerCAmelCase__							:Dict		,    lowerCAmelCase__							:Tuple     )  ->Tuple:
										lowercase         =      TFCvtModel(config=lowerCAmelCase__     )
										lowercase         =      model(lowerCAmelCase__		,    training=lowerCAmelCase__     )
										lowercase         =      (self.image_size, self.image_size)
										lowercase     ,	lowercase         =      image_size[0], image_size[1]
										for i in range(len(self.depth     )     ):
														lowercase         =      floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1     )
														lowercase         =      floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1     )
										self.parent.assertEqual(result.last_hidden_state.shape		,    (self.batch_size, self.embed_dim[-1], height, width)     )





						def        SCREAMING_SNAKE_CASE(			self							:List[str]		,    lowerCAmelCase__							:Optional[int]		,    lowerCAmelCase__							:int		,    lowerCAmelCase__							:Tuple     )  ->Any:
										lowercase         =      self.num_labels
										lowercase         =      TFCvtForImageClassification(lowerCAmelCase__     )
										lowercase         =      model(lowerCAmelCase__		,    labels=lowerCAmelCase__		,    training=lowerCAmelCase__     )
										self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)     )





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->List[Any]:
										lowercase         =      self.prepare_config_and_inputs()
										lowercase     ,	lowercase     ,	lowercase         =      config_and_inputs
										lowercase         =      {"pixel_values": pixel_values}
										return config, inputs_dict





@require_tf
class   UpperCamelCase_      (      __snake_case		,    __snake_case		,    unittest.TestCase		):







						'''simple docstring'''



						UpperCamelCase      :  List[str]				   =					(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
						UpperCamelCase      :  List[str]				   =					(
						    {'feature-extraction': TFCvtModel, 'image-classification': TFCvtForImageClassification}
						    if is_tf_available()
						    else {}
						)
						UpperCamelCase      :  Tuple				   =					False
						UpperCamelCase      :  Any				   =					False
						UpperCamelCase      :  List[str]				   =					False
						UpperCamelCase      :  str				   =					False
						UpperCamelCase      :  Tuple				   =					False





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->Any:
										lowercase         =      TFCvtModelTester(self     )
										lowercase         =      TFCvtConfigTester(self		,    config_class=lowerCAmelCase__		,    has_text_modality=lowerCAmelCase__		,    hidden_size=37     )





						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->Optional[int]:
										self.config_tester.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()





						@unittest.skip(reason="Cvt does not output attentions"     )
						def        SCREAMING_SNAKE_CASE(			self							:Tuple     )  ->Optional[Any]:
										pass





						@unittest.skip(reason="Cvt does not use inputs_embeds"     )
						def        SCREAMING_SNAKE_CASE(			self							:Tuple     )  ->List[str]:
										pass





						@unittest.skip(reason="Cvt does not support input and output embeddings"     )
						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->Optional[Any]:
										pass





						@unittest.skipIf(
						    not is_tf_available() or len(tf.config.list_physical_devices("GPU"     )     ) == 0		,    reason="TF does not support backprop for grouped convolutions on CPU."		,    )
						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->int:
										super().test_dataset_conversion()





						@unittest.skipIf(
						    not is_tf_available() or len(tf.config.list_physical_devices("GPU"     )     ) == 0		,    reason="TF does not support backprop for grouped convolutions on CPU."		,    )
						@slow
						def        SCREAMING_SNAKE_CASE(			self							:str     )  ->List[Any]:
										super().test_keras_fit()





						@unittest.skip(reason="Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8"     )
						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Any:
										lowercase         =      tf.keras.mixed_precision.Policy("mixed_float16"     )
										tf.keras.mixed_precision.set_global_policy(lowerCAmelCase__     )
										super().test_keras_fit()
										tf.keras.mixed_precision.set_global_policy("float32"     )





						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->List[str]:
										lowercase     ,	lowercase         =      self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowercase         =      model_class(lowerCAmelCase__     )
														lowercase         =      inspect.signature(model.call     )
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														lowercase         =      [*signature.parameters.keys()]

														lowercase         =      ["pixel_values"]
														self.assertListEqual(arg_names[:1]		,    lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:List[Any]     )  ->Optional[Any]:






										def check_hidden_states_output(lowerCAmelCase__							:Tuple		,    lowerCAmelCase__							:Optional[Any]		,    lowerCAmelCase__							:Optional[Any]     ):
														lowercase         =      model_class(lowerCAmelCase__     )

														lowercase         =      model(**self._prepare_for_class(lowerCAmelCase__		,    lowerCAmelCase__     )     )
														lowercase         =      outputs.hidden_states

														lowercase         =      len(self.model_tester.depth     )
														self.assertEqual(len(lowerCAmelCase__     )		,    lowerCAmelCase__     )

														# verify the first hidden states (first block)
														self.assertListEqual(
														    list(hidden_states[0].shape[-3:]     )		,    [
														        self.model_tester.embed_dim[0],
														        self.model_tester.image_size // 4,
														        self.model_tester.image_size // 4,
														    ]		,    )

										lowercase     ,	lowercase         =      self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														lowercase         =      True
														check_hidden_states_output(lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__     )

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														lowercase         =      True

														check_hidden_states_output(lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]     )  ->Union[str, Any]:
										lowercase         =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Dict:
										lowercase         =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__     )





						@slow
						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->Any:






										for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowercase         =      TFCvtModel.from_pretrained(lowerCAmelCase__     )
														self.assertIsNotNone(lowerCAmelCase__     )




def  __snake_case							(	):







				'''simple docstring'''


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





@require_tf
@require_vision
class   UpperCamelCase_      (      unittest.TestCase		):







						'''simple docstring'''



						@cached_property
						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->Dict:
										return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )





						@slow
						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->Optional[int]:
										lowercase         =      TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )

										lowercase         =      self.default_image_processor
										lowercase         =      prepare_img()
										lowercase         =      image_processor(images=lowerCAmelCase__		,    return_tensors="tf"     )

										# forward pass
										lowercase         =      model(**lowerCAmelCase__     )

										# verify the logits
										lowercase         =      tf.TensorShape((1, 1000)     )
										self.assertEqual(outputs.logits.shape		,    lowerCAmelCase__     )

										lowercase         =      tf.constant([0.92_85, 0.90_15, -0.31_50]     )
										self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()		,    lowerCAmelCase__		,    atol=1E-4     )     )




"""simple docstring"""



import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class    __a						( __snake_case					,			unittest.TestCase							):
				lowerCamelCase     :       Any			       =GPTSanJapaneseTokenizer
				lowerCamelCase     :       List[str]			       =False
				lowerCamelCase     :       List[str]			       ={'do_clean_text': False, 'add_prefix_space': False}







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					super().setUp()

					# fmt: off
					lowerCAmelCase_      							=			['''こん''', '''こんに''', '''にちは''', '''ばんは''', '''世界,㔺界''', '''、''', '''。''', '''<BR>''', '''<SP>''', '''<TAB>''', '''<URL>''', '''<EMAIL>''', '''<TEL>''', '''<DATE>''', '''<PRICE>''', '''<BLOCK>''', '''<KIGOU>''', '''<U2000U2BFF>''', '''<|emoji1|>''', '''<unk>''', '''<|bagoftoken|>''', '''<|endoftext|>''']
					# fmt: on
					lowerCAmelCase_      							=			{'''emoji''': {'''\ud83d\ude00''': '''<|emoji1|>'''}, '''emoji_inv''': {'''<|emoji1|>''': '''\ud83d\ude00'''}}  # 😀
					lowerCAmelCase_      							=			{'''unk_token''': '''<unk>'''}

					lowerCAmelCase_      							=			os.path.join(self.tmpdirname      ,	VOCAB_FILES_NAMES['''vocab_file''']   )
					lowerCAmelCase_      							=			os.path.join(self.tmpdirname      ,	VOCAB_FILES_NAMES['''emoji_file''']   )
					with open(self.vocab_file      ,	'''w'''      ,	encoding='''utf-8'''   ) as vocab_writer:
						vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]   )   )
					with open(self.emoji_file      ,	'''w'''   ) as emoji_writer:
						emoji_writer.write(json.dumps(UpperCAmelCase   )   )







				def      lowerCamelCase_     ( self      ,	**UpperCAmelCase   ):

					'''simple docstring'''






					kwargs.update(self.special_tokens_map   )
					return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname      ,	**UpperCAmelCase   )







				def      lowerCamelCase_     ( self      ,	UpperCAmelCase   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			'''こんにちは、世界。 \nこんばんは、㔺界。😀'''
					lowerCAmelCase_      							=			'''こんにちは、世界。 \nこんばんは、世界。😀'''
					return input_text, output_text







				def      lowerCamelCase_     ( self      ,	UpperCAmelCase   ):

					'''simple docstring'''






					lowerCAmelCase_							,	lowerCAmelCase_      							=			self.get_input_output_texts(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.encode(UpperCAmelCase      ,	add_special_tokens=UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase      ,	clean_up_tokenization_spaces=UpperCAmelCase   )
					return text, ids







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass  # TODO add if relevant







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass  # TODO add if relevant







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass  # TODO add if relevant







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.get_tokenizer()

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、世界。　こんばんは、㔺界。'''
					lowerCAmelCase_      							=			['''こん''', '''にちは''', '''、''', '''世界''', '''。''', '''<SP>''', '''こん''', '''ばんは''', '''、''', '''㔺界''', '''。''']
					lowerCAmelCase_      							=			tokenizer.tokenize(UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )

					# Testing conversion to ids without special tokens
					lowerCAmelCase_      							=			[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
					lowerCAmelCase_      							=			tokenizer.convert_tokens_to_ids(UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )

					# Testing conversion to ids with special tokens
					lowerCAmelCase_      							=			tokens + [tokenizer.unk_token]
					lowerCAmelCase_      							=			[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
					lowerCAmelCase_      							=			tokenizer.convert_tokens_to_ids(UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.get_tokenizer()

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'''
					lowerCAmelCase_      							=			'''こんにちは、、、、世界。こんばんは、、、、世界。'''
					lowerCAmelCase_      							=			tokenizer.encode(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、世界。'''
					lowerCAmelCase_      							=			'''こんばんは、㔺界。😀'''
					lowerCAmelCase_      							=			'''こんにちは、世界。こんばんは、世界。😀'''
					lowerCAmelCase_      							=			tokenizer.encode(prefix_text + input_text   )
					lowerCAmelCase_      							=			tokenizer.encode(''''''      ,	prefix_text=prefix_text + input_text   )
					lowerCAmelCase_      							=			tokenizer.encode(UpperCAmelCase      ,	prefix_text=UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.decode(UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					# Testing tokenization
					lowerCAmelCase_      							=			'''こんにちは、世界。'''
					lowerCAmelCase_      							=			'''こんばんは、㔺界。😀'''

					lowerCAmelCase_      							=			len(tokenizer.encode(UpperCAmelCase   )   ) - 2
					lowerCAmelCase_      							=			len(tokenizer.encode(UpperCAmelCase   )   ) - 2

					lowerCAmelCase_      							=			[1] + [0] * (len_prefix + len_text + 1)
					lowerCAmelCase_      							=			[1] * (len_prefix + len_text + 1) + [0]
					lowerCAmelCase_      							=			[1] + [1] * (len_prefix) + [0] * (len_text + 1)

					lowerCAmelCase_      							=			tokenizer(prefix_text + input_text   ).token_type_ids
					lowerCAmelCase_      							=			tokenizer(''''''      ,	prefix_text=prefix_text + input_text   ).token_type_ids
					lowerCAmelCase_      							=			tokenizer(UpperCAmelCase      ,	prefix_text=UpperCAmelCase   ).token_type_ids
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertListEqual(UpperCAmelCase      ,	UpperCAmelCase   )







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					lowerCAmelCase_      							=			tokenizer.encode('''あンいワ'''   )
					lowerCAmelCase_      							=			tokenizer.encode(''''''      ,	prefix_text='''あンいワ'''   )
					lowerCAmelCase_      							=			tokenizer.encode('''いワ'''      ,	prefix_text='''あン'''   )

					self.assertEqual(tokenizer.decode(UpperCAmelCase   )      ,	tokenizer.decode(UpperCAmelCase   )   )
					self.assertEqual(tokenizer.decode(UpperCAmelCase   )      ,	tokenizer.decode(UpperCAmelCase   )   )
					self.assertNotEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertNotEqual(UpperCAmelCase      ,	UpperCAmelCase   )
					self.assertEqual(x_token_a[1]      ,	x_token_a[-1]   )  # SEG token
					self.assertEqual(x_token_a[1]      ,	x_token_a[3]   )  # SEG token







				@slow
				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''   )

					lowerCAmelCase_      							=			[['''武田信玄''', '''は、'''], ['''織田信長''', '''の配下の、''']]
					lowerCAmelCase_      							=			tokenizer(UpperCAmelCase      ,	padding=UpperCAmelCase   )
					lowerCAmelCase_      							=			tokenizer.batch_encode_plus(UpperCAmelCase      ,	padding=UpperCAmelCase   )

					# fmt: off
					lowerCAmelCase_      							=			[[3_5993, 8640, 2_5948, 3_5998, 3_0647, 3_5675, 3_5999, 3_5999], [3_5993, 1_0382, 9868, 3_5998, 3_0646, 9459, 3_0646, 3_5675]]
					lowerCAmelCase_      							=			[[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
					lowerCAmelCase_      							=			[[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
					# fmt: on
					self.assertListEqual(x_token.input_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token.token_type_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token.attention_mask      ,	UpperCAmelCase   )
					self.assertListEqual(x_token_a.input_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token_a.token_type_ids      ,	UpperCAmelCase   )
					self.assertListEqual(x_token_a.attention_mask      ,	UpperCAmelCase   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					pass