




'''simple docstring'''

import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

							if is_vision_available():
														from transformers import MaskaFormerImageProcessor

if is_vision_available():
							from PIL import Image






class 		a							:


				def __init__(						self       :   Any			,							lowercase_       :   List[Any]			,							lowercase_       :   int=2			,							lowercase_       :   Optional[Any]=True			,							lowercase_       :   Any=False			,							lowercase_       :   Tuple=10			,							lowercase_       :   List[Any]=3			,							lowercase_       :   Union[str, Any]=32 * 8			,							lowercase_       :   Union[str, Any]=32 * 8			,							lowercase_       :   str=4			,							lowercase_       :   Optional[Any]=64			,							):
									snake_case_		     =							parent
									snake_case_		     =							batch_size
									snake_case_		     =							is_training
									snake_case_		     =							use_auxiliary_loss
									snake_case_		     =							num_queries
									snake_case_		     =							num_channels
									snake_case_		     =							min_size
									snake_case_		     =							max_size
									snake_case_		     =							num_labels
									snake_case_		     =							hidden_dim
									snake_case_		     =							hidden_dim


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]   ).to(
									    lowercase_   )

									snake_case_		     =							torch.ones([self.batch_size, self.min_size, self.max_size]			,							device=lowercase_   )

									snake_case_		     =							(
									    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]			,							device=lowercase_   ) > 0.5
									).float()
									snake_case_		     =							(torch.rand((self.batch_size, self.num_labels)			,							device=lowercase_   ) > 0.5).long()

									snake_case_		     =							self.get_config()
									return config, pixel_values, pixel_mask, mask_labels, class_labels


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							MaskaFormerConfig(
									    hidden_size=self.hidden_dim			,							)
									snake_case_		     =							self.num_queries
									snake_case_		     =							self.num_labels

									snake_case_		     =							[1, 1, 1, 1]
									snake_case_		     =							self.num_channels

									snake_case_		     =							64
									snake_case_		     =							128
									snake_case_		     =							self.hidden_dim
									snake_case_		     =							self.hidden_dim
									snake_case_		     =							self.hidden_dim
									return config


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							self.prepare_config_and_inputs()
									snake_case_		     =							{'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
									return config, inputs_dict


				def     A_					(						self       :   Optional[int]			,							lowercase_       :   List[str]			,							lowercase_       :   Optional[int]   ):
									snake_case_		     =							output.encoder_hidden_states
									snake_case_		     =							output.pixel_decoder_hidden_states
									snake_case_		     =							output.transformer_decoder_hidden_states

									self.parent.assertTrue(len(lowercase_   )			,							len(config.backbone_config.depths   )   )
									self.parent.assertTrue(len(lowercase_   )			,							len(config.backbone_config.depths   )   )
									self.parent.assertTrue(len(lowercase_   )			,							config.decoder_layers   )


				def     A_					(						self       :   Dict			,							lowercase_       :   Any			,							lowercase_       :   Tuple			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Tuple=False   ):
									with torch.no_grad():
														snake_case_		     =							MaskaFormerModel(config=lowercase_   )
														model.to(lowercase_   )
														model.eval()

														snake_case_		     =							model(pixel_values=lowercase_			,							pixel_mask=lowercase_   )
														snake_case_		     =							model(lowercase_			,							output_hidden_states=lowercase_   )

									self.parent.assertEqual(
									    output.transformer_decoder_last_hidden_state.shape			,							(self.batch_size, self.num_queries, self.hidden_dim)			,							)
									# let's ensure the other two hidden state exists
									self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None   )
									self.parent.assertTrue(output.encoder_last_hidden_state is not None   )

									if output_hidden_states:
														self.check_output_hidden_state(lowercase_			,							lowercase_   )


				def     A_					(						self       :   Union[str, Any]			,							lowercase_       :   Optional[int]			,							lowercase_       :   Dict			,							lowercase_       :   Any			,							lowercase_       :   Dict			,							lowercase_       :   Any   ):
									snake_case_		     =							MaskaFormerForUniversalSegmentation(config=lowercase_   )
									model.to(lowercase_   )
									model.eval()

									def comm_check_on_output(lowercase_       :   Optional[Any]   ):
														# let's still check that all the required stuff is there
														self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None   )
														self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None   )
														self.parent.assertTrue(result.encoder_last_hidden_state is not None   )
														# okay, now we need to check the logits shape
														# due to the encoder compression, masks have a //4 spatial size
														self.parent.assertEqual(
														    result.masks_queries_logits.shape			,							(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)			,							)
														# + 1 for null class
														self.parent.assertEqual(
														    result.class_queries_logits.shape			,							(self.batch_size, self.num_queries, self.num_labels + 1)   )

									with torch.no_grad():
														snake_case_		     =							model(pixel_values=lowercase_			,							pixel_mask=lowercase_   )
														snake_case_		     =							model(lowercase_   )

														comm_check_on_output(lowercase_   )

														snake_case_		     =							model(
														    pixel_values=lowercase_			,							pixel_mask=lowercase_			,							mask_labels=lowercase_			,							class_labels=lowercase_   )

									comm_check_on_output(lowercase_   )

									self.parent.assertTrue(result.loss is not None   )
									self.parent.assertEqual(result.loss.shape			,							torch.Size([1]   )   )







@require_torch
class 		a							(  _lowerCamelCase  ,	_lowerCamelCase  ,	unittest.TestCase	):
				snake_case_           =						(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
				snake_case_           =						{"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

				snake_case_           =						False
				snake_case_           =						False
				snake_case_           =						False
				snake_case_           =						False


				def     A_					(						self       :   Tuple   ):
									snake_case_		     =							MaskaFormerModelTester(self   )
									snake_case_		     =							ConfigTester(self			,							config_class=lowercase_			,							has_text_modality=lowercase_   )


				def     A_					(						self       :   List[Any]   ):
									self.config_tester.run_common_tests()


				def     A_					(						self       :   Tuple   ):
									snake_case_     ,snake_case_		     =							self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.create_and_check_maskaformer_model(lowercase_			,							**lowercase_			,							output_hidden_states=lowercase_   )


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*lowercase_   )


				@unittest.skip(reason='''Mask2Former does not use inputs_embeds'''   )
				def     A_					(						self       :   Tuple   ):
									pass


				@unittest.skip(reason='''Mask2Former does not have a get_input_embeddings method'''   )
				def     A_					(						self       :   Union[str, Any]   ):
									pass


				@unittest.skip(reason='''Mask2Former is not a generative model'''   )
				def     A_					(						self       :   List[Any]   ):
									pass


				@unittest.skip(reason='''Mask2Former does not use token embeddings'''   )
				def     A_					(						self       :   Optional[int]   ):
									pass


				@require_torch_multi_gpu
				@unittest.skip(
				    reason='''Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''   )
				def     A_					(						self       :   List[str]   ):
									pass


				@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
				def     A_					(						self       :   List[str]   ):
									pass


				def     A_					(						self       :   Any   ):
									snake_case_     ,snake_case_		     =							self.model_tester.prepare_config_and_inputs_for_common()

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

														snake_case_		     =							['''pixel_values''']
														self.assertListEqual(arg_names[:1]			,							lowercase_   )


				@slow
				def     A_					(						self       :   Tuple   ):
									for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
														snake_case_		     =							MaskaFormerModel.from_pretrained(lowercase_   )
														self.assertIsNotNone(lowercase_   )


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							(self.model_tester.min_size,) * 2
									snake_case_		     =							{
									    '''pixel_values''': torch.randn((2, 3, *size)			,							device=lowercase_   ),
									    '''mask_labels''': torch.randn((2, 10, *size)			,							device=lowercase_   ),
									    '''class_labels''': torch.zeros(2			,							10			,							device=lowercase_   ).long(),
									}
									snake_case_		     =							self.model_tester.get_config()

									snake_case_		     =							MaskaFormerForUniversalSegmentation(lowercase_   ).to(lowercase_   )
									snake_case_		     =							model(**lowercase_   )
									self.assertTrue(outputs.loss is not None   )


				def     A_					(						self       :   List[str]   ):
									snake_case_     ,snake_case_		     =							self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.create_and_check_maskaformer_model(lowercase_			,							**lowercase_			,							output_hidden_states=lowercase_   )


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

									for model_class in self.all_model_classes:
														snake_case_		     =							model_class(lowercase_   ).to(lowercase_   )
														snake_case_		     =							model(**lowercase_			,							output_attentions=lowercase_   )
														self.assertTrue(outputs.attentions is not None   )


				def     A_					(						self       :   Union[str, Any]   ):
									if not self.model_tester.is_training:
														return

									snake_case_		     =							self.all_model_classes[1]
									snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							self.model_tester.prepare_config_and_inputs()

									snake_case_		     =							model_class(lowercase_   )
									model.to(lowercase_   )
									model.train()

									snake_case_		     =							model(lowercase_			,							mask_labels=lowercase_			,							class_labels=lowercase_   ).loss
									loss.backward()


				def     A_					(						self       :   str   ):
									snake_case_		     =							self.all_model_classes[1]
									snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							self.model_tester.prepare_config_and_inputs()
									snake_case_		     =							True
									snake_case_		     =							True

									snake_case_		     =							model_class(lowercase_   ).to(lowercase_   )
									model.train()

									snake_case_		     =							model(lowercase_			,							mask_labels=lowercase_			,							class_labels=lowercase_   )

									snake_case_		     =							outputs.encoder_hidden_states[0]
									encoder_hidden_states.retain_grad()

									snake_case_		     =							outputs.pixel_decoder_hidden_states[0]
									pixel_decoder_hidden_states.retain_grad()

									snake_case_		     =							outputs.transformer_decoder_hidden_states[0]
									transformer_decoder_hidden_states.retain_grad()

									snake_case_		     =							outputs.attentions[0]
									attentions.retain_grad()

									outputs.loss.backward(retain_graph=lowercase_   )

									self.assertIsNotNone(encoder_hidden_states.grad   )
									self.assertIsNotNone(pixel_decoder_hidden_states.grad   )
									self.assertIsNotNone(transformer_decoder_hidden_states.grad   )
									self.assertIsNotNone(attentions.grad   )







a    :							Tuple										=    1E-4


def 						__magic_name__       (      )						->   List[Any]:

					'''simple docstring'''

					snake_case_		     =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
					return image






@require_vision
@slow
class 		a							(  unittest.TestCase	):


				@cached_property
				def     A_					(						self       :   Optional[int]   ):
									return "facebook/mask2former-swin-small-coco-instance"


				@cached_property
				def     A_					(						self       :   Optional[int]   ):
									return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints   ) if is_vision_available() else None


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							MaskaFormerModel.from_pretrained(self.model_checkpoints   ).to(lowercase_   )
									snake_case_		     =							self.default_image_processor
									snake_case_		     =							prepare_img()
									snake_case_		     =							image_processor(lowercase_			,							return_tensors='''pt'''   ).to(lowercase_   )
									snake_case_		     =							inputs['''pixel_values'''].shape
									# check size is divisible by 32
									self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0   )
									# check size
									self.assertEqual(lowercase_			,							(1, 3, 384, 384)   )

									with torch.no_grad():
														snake_case_		     =							model(**lowercase_   )

									snake_case_		     =							torch.tensor(
									    [[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]]   ).to(lowercase_   )
									self.assertTrue(
									    torch.allclose(
									        outputs.encoder_last_hidden_state[0, 0, :3, :3]			,							lowercase_			,							atol=lowercase_   )   )

									snake_case_		     =							torch.tensor(
									    [[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]]   ).to(lowercase_   )
									self.assertTrue(
									    torch.allclose(
									        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]			,							lowercase_			,							atol=lowercase_   )   )

									snake_case_		     =							torch.tensor(
									    [[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]]   ).to(lowercase_   )
									self.assertTrue(
									    torch.allclose(
									        outputs.transformer_decoder_last_hidden_state[0, :3, :3]			,							lowercase_			,							atol=lowercase_   )   )


				def     A_					(						self       :   Dict   ):
									snake_case_		     =							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints   ).to(lowercase_   ).eval()
									snake_case_		     =							self.default_image_processor
									snake_case_		     =							prepare_img()
									snake_case_		     =							image_processor(lowercase_			,							return_tensors='''pt'''   ).to(lowercase_   )
									snake_case_		     =							inputs['''pixel_values'''].shape
									# check size is divisible by 32
									self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0   )
									# check size
									self.assertEqual(lowercase_			,							(1, 3, 384, 384)   )

									with torch.no_grad():
														snake_case_		     =							model(**lowercase_   )
									# masks_queries_logits
									snake_case_		     =							outputs.masks_queries_logits
									self.assertEqual(
									    masks_queries_logits.shape			,							(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)   )
									snake_case_		     =							[
									    [-8.7839, -9.0056, -8.8121],
									    [-7.4104, -7.0313, -6.5401],
									    [-6.6105, -6.3427, -6.4675],
									]
									snake_case_		     =							torch.tensor(lowercase_   ).to(lowercase_   )
									self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]			,							lowercase_			,							atol=lowercase_   )   )
									# class_queries_logits
									snake_case_		     =							outputs.class_queries_logits
									self.assertEqual(class_queries_logits.shape			,							(1, model.config.num_queries, model.config.num_labels + 1)   )
									snake_case_		     =							torch.tensor(
									    [
									        [1.8324, -8.0835, -4.1922],
									        [0.8450, -9.0050, -3.6053],
									        [0.3045, -7.7293, -3.0275],
									    ]   ).to(lowercase_   )
									self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]			,							lowercase_			,							atol=lowercase_   )   )


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints   ).to(lowercase_   ).eval()
									snake_case_		     =							self.default_image_processor

									snake_case_		     =							image_processor(
									    [np.zeros((3, 800, 1333)   ), np.zeros((3, 800, 1333)   )]			,							segmentation_maps=[np.zeros((384, 384)   ).astype(np.floataa   ), np.zeros((384, 384)   ).astype(np.floataa   )]			,							return_tensors='''pt'''			,							)

									snake_case_		     =							inputs['''pixel_values'''].to(lowercase_   )
									snake_case_		     =							[el.to(lowercase_   ) for el in inputs['''mask_labels''']]
									snake_case_		     =							[el.to(lowercase_   ) for el in inputs['''class_labels''']]

									with torch.no_grad():
														snake_case_		     =							model(**lowercase_   )

									self.assertTrue(outputs.loss is not None   )







'''simple docstring'''

import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class 		a							(  _lowerCamelCase  ,	unittest.TestCase	):
				snake_case_           =						CLIPTokenizer
				snake_case_           =						CLIPTokenizerFast
				snake_case_           =						True
				snake_case_           =						{}
				snake_case_           =						False


				def     A_					(						self       :   List[Any]   ):
									super().setUp()

									# fmt: off
									snake_case_		     =							['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>''']
									# fmt: on
									snake_case_		     =							dict(zip(lowercase_			,							range(len(lowercase_   )   )   )   )
									snake_case_		     =							['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''']
									snake_case_		     =							{'''unk_token''': '''<unk>'''}

									snake_case_		     =							os.path.join(self.tmpdirname			,							VOCAB_FILES_NAMES['''vocab_file''']   )
									snake_case_		     =							os.path.join(self.tmpdirname			,							VOCAB_FILES_NAMES['''merges_file''']   )
									with open(self.vocab_file			,							'''w'''			,							encoding='''utf-8'''   ) as fp:
														fp.write(json.dumps(lowercase_   ) + '''\n'''   )
									with open(self.merges_file			,							'''w'''			,							encoding='''utf-8'''   ) as fp:
														fp.write('''\n'''.join(lowercase_   )   )


				def     A_					(						self       :   Tuple			,							**lowercase_       :   Tuple   ):
									kwargs.update(self.special_tokens_map   )
									return CLIPTokenizer.from_pretrained(self.tmpdirname			,							**lowercase_   )


				def     A_					(						self       :   List[str]			,							**lowercase_       :   Dict   ):
									kwargs.update(self.special_tokens_map   )
									return CLIPTokenizerFast.from_pretrained(self.tmpdirname			,							**lowercase_   )


				def     A_					(						self       :   Optional[int]			,							lowercase_       :   Optional[int]   ):
									snake_case_		     =							'''lower newer'''
									snake_case_		     =							'''lower newer'''
									return input_text, output_text


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							CLIPTokenizer(self.vocab_file			,							self.merges_file			,							**self.special_tokens_map   )
									snake_case_		     =							'''lower newer'''
									snake_case_		     =							['''lo''', '''w''', '''er</w>''', '''n''', '''e''', '''w''', '''er</w>''']
									snake_case_		     =							tokenizer.tokenize(lowercase_   )
									self.assertListEqual(lowercase_			,							lowercase_   )

									snake_case_		     =							tokens + [tokenizer.unk_token]
									snake_case_		     =							[10, 2, 16, 9, 3, 2, 16, 20]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase_   )			,							lowercase_   )


				@require_ftfy
				def     A_					(						self       :   Optional[Any]   ):
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
																			snake_case_		     =							self.tokenizer_class.from_pretrained(lowercase_			,							**lowercase_   )
																			snake_case_		     =							self.rust_tokenizer_class.from_pretrained(lowercase_			,							**lowercase_   )

																			snake_case_		     =							'''A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'''
																			snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																			snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																			self.assertListEqual(lowercase_			,							lowercase_   )

																			# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
																			# with Tilde) encoded in 2 different ways
																			snake_case_		     =							'''xa\u0303y''' + ''' ''' + '''x\xe3y'''
																			snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																			snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																			self.assertListEqual(lowercase_			,							lowercase_   )

																			# Test that the tokenization is identical on unicode of space type
																			snake_case_		     =							[
																			    '''\u0009''',  # (horizontal tab, '\t')
																			    '''\u000B''',  # (vertical tab)
																			    '''\u000C''',  # (form feed)
																			    '''\u0020''',  # (space, ' ')
																			    '''\u200E''',  # (left-to-right mark):w
																			    '''\u200F''',  # (right-to-left mark)
																			]
																			for unicode_seq in spaces_unicodes:
																								snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																								snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																								self.assertListEqual(lowercase_			,							lowercase_   )

																			# Test that the tokenization is identical on unicode of line break type
																			snake_case_		     =							[
																			    '''\u000A''',  # (line feed, '\n')
																			    '''\r\n''',  # (carriage return and line feed, '\r\n')
																			    '''\u000D''',  # (carriage return, '\r')
																			    '''\r''',  # (carriage return, '\r')
																			    '''\u000D''',  # (carriage return, '\r')
																			    '''\u2028''',  # (line separator)
																			    '''\u2029''',  # (paragraph separator)
																			    # "\u0085", # (next line)
																			]

																			# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
																			# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
																			# space (and thus into an empty list).

																			for unicode_seq in line_break_unicodes:
																								snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																								snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																								self.assertListEqual(lowercase_			,							lowercase_   )


				def     A_					(						self       :   List[str]   ):
									# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
																			snake_case_		     =							'''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
																			snake_case_		     =							F"{text_of_1_token} {text_of_1_token}"

																			snake_case_		     =							self.rust_tokenizer_class.from_pretrained(
																			    lowercase_			,							use_fast=lowercase_			,							)
																			snake_case_		     =							tokenizer_r(lowercase_			,							return_offsets_mapping=lowercase_			,							add_special_tokens=lowercase_   )
																			self.assertEqual(encoding.offset_mapping[0]			,							(0, len(lowercase_   ))   )
																			self.assertEqual(
																			    encoding.offset_mapping[1]			,							(len(lowercase_   ) + 1, len(lowercase_   ) + 1 + len(lowercase_   ))			,							)

																			snake_case_		     =							F" {text}"

																			snake_case_		     =							self.rust_tokenizer_class.from_pretrained(
																			    lowercase_			,							use_fast=lowercase_			,							)
																			snake_case_		     =							tokenizer_r(lowercase_			,							return_offsets_mapping=lowercase_			,							add_special_tokens=lowercase_   )
																			self.assertEqual(encoding.offset_mapping[0]			,							(1, 1 + len(lowercase_   ))   )
																			self.assertEqual(
																			    encoding.offset_mapping[1]			,							(1 + len(lowercase_   ) + 1, 1 + len(lowercase_   ) + 1 + len(lowercase_   ))			,							)


				def     A_					(						self       :   Optional[Any]   ):
									# Test related to the breaking change introduced in transformers v4.17.0
									# We need to check that an error in raised when the user try to load a previous version of the tokenizer.
									with self.assertRaises(lowercase_   ) as context:
														self.rust_tokenizer_class.from_pretrained('''robot-test/old-clip-tokenizer'''   )

									self.assertTrue(
									    context.exception.args[0].startswith(
									        '''The `backend_tokenizer` provided does not match the expected format.'''   )   )


				@require_ftfy
				def     A_					(						self       :   List[str]   ):
									super().test_tokenization_python_rust_equals()


				def     A_					(						self       :   List[Any]   ):
									# CLIP always lower cases letters
									pass

