





'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()




class      UpperCamelCase__					(					lowercase_						,					unittest.TestCase			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	KandinskyImgaImgPipeline
					SCREAMING_SNAKE_CASE__				=	['''prompt''', '''image_embeds''', '''negative_image_embeds''', '''image''']
					SCREAMING_SNAKE_CASE__				=	[
					    '''prompt''',
					    '''negative_prompt''',
					    '''image_embeds''',
					    '''negative_image_embeds''',
					    '''image''',
					]
					SCREAMING_SNAKE_CASE__				=	[
					    '''generator''',
					    '''height''',
					    '''width''',
					    '''strength''',
					    '''guidance_scale''',
					    '''negative_prompt''',
					    '''num_inference_steps''',
					    '''return_dict''',
					    '''guidance_scale''',
					    '''num_images_per_prompt''',
					    '''output_type''',
					    '''return_dict''',
					]
					SCREAMING_SNAKE_CASE__				=	False


					@property
					def lowerCamelCase_			(						self				:			Tuple						):

							'''simple docstring'''



							return 32


					@property
					def lowerCamelCase_			(						self				:			Any						):

							'''simple docstring'''



							return 32


					@property
					def lowerCamelCase_			(						self				:			Union[str, Any]						):

							'''simple docstring'''



							return self.time_input_dim


					@property
					def lowerCamelCase_			(						self				:			Any						):

							'''simple docstring'''



							return self.time_input_dim * 4


					@property
					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							return 1_00


					@property
					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[Any]		=			XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""						)
							return tokenizer


					@property
					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



							torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				List[str]		=			MCLIPConfig(
							    numDims=self.cross_attention_dim      ,						transformerDimensions=self.text_embedder_hidden_size      ,						hidden_size=self.text_embedder_hidden_size      ,						intermediate_size=37      ,						num_attention_heads=4      ,						num_hidden_layers=5      ,						vocab_size=10_05      ,						)

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			MultilingualCLIP(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				List[str]		=			text_encoder.eval()

							return text_encoder


					@property
					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							torch.manual_seed(0						)

							SCREAMING_SNAKE_CASE :				Optional[int]		=			{
							    """in_channels""": 4,
							    # Out channels is double in channels because predicts mean and variance
							    """out_channels""": 8,
							    """addition_embed_type""": """text_image""",
							    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
							    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
							    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
							    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
							    """layers_per_block""": 1,
							    """encoder_hid_dim""": self.text_embedder_hidden_size,
							    """encoder_hid_dim_type""": """text_image_proj""",
							    """cross_attention_dim""": self.cross_attention_dim,
							    """attention_head_dim""": 4,
							    """resnet_time_scale_shift""": """scale_shift""",
							    """class_embed_type""": None,
							}

							SCREAMING_SNAKE_CASE :				Any		=			UNetaDConditionModel(**lowerCamelCase_						)
							return model


					@property
					def lowerCamelCase_			(						self				:			Union[str, Any]						):

							'''simple docstring'''



							return {
							    "block_out_channels": [32, 64],
							    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
							    "in_channels": 3,
							    "latent_channels": 4,
							    "layers_per_block": 1,
							    "norm_num_groups": 8,
							    "norm_type": "spatial",
							    "num_vq_embeddings": 12,
							    "out_channels": 3,
							    "up_block_types": [
							        "AttnUpDecoderBlock2D",
							        "UpDecoderBlock2D",
							    ],
							    "vq_embed_dim": 4,
							}


					@property
					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				int		=			VQModel(**self.dummy_movq_kwargs						)
							return model


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			self.dummy_text_encoder
							SCREAMING_SNAKE_CASE :				str		=			self.dummy_tokenizer
							SCREAMING_SNAKE_CASE :				Dict		=			self.dummy_unet
							SCREAMING_SNAKE_CASE :				List[Any]		=			self.dummy_movq

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			{
							    """num_train_timesteps""": 10_00,
							    """beta_schedule""": """linear""",
							    """beta_start""": 0.00_085,
							    """beta_end""": 0.012,
							    """clip_sample""": False,
							    """set_alpha_to_one""": False,
							    """steps_offset""": 0,
							    """prediction_type""": """epsilon""",
							    """thresholding""": False,
							}

							SCREAMING_SNAKE_CASE :				Dict		=			DDIMScheduler(**lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				List[str]		=			{
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """unet""": unet,
							    """scheduler""": scheduler,
							    """movq""": movq,
							}

							return components


					def lowerCamelCase_			(						self				:			Union[str, Any]      ,						lowerCamelCase_				:			Tuple      ,						lowerCamelCase_				:			Dict=0						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[Any]		=			floats_tensor((1, self.cross_attention_dim)      ,						rng=random.Random(lowerCamelCase_						)						).to(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				List[str]		=			floats_tensor((1, self.cross_attention_dim)      ,						rng=random.Random(seed + 1						)						).to(lowerCamelCase_						)
							# create init_image
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			floats_tensor((1, 3, 64, 64)      ,						rng=random.Random(lowerCamelCase_						)						).to(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			image.cpu().permute(0      ,						2      ,						3      ,						1						)[0]
							SCREAMING_SNAKE_CASE :				Tuple		=			Image.fromarray(np.uinta(lowerCamelCase_						)						).convert("""RGB"""						).resize((2_56, 2_56)						)

							if str(lowerCamelCase_						).startswith("""mps"""						):
									SCREAMING_SNAKE_CASE :				List[Any]		=			torch.manual_seed(lowerCamelCase_						)
							else:
									SCREAMING_SNAKE_CASE :				str		=			torch.Generator(device=lowerCamelCase_						).manual_seed(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				str		=			{
							    """prompt""": """horse""",
							    """image""": init_image,
							    """image_embeds""": image_embeds,
							    """negative_image_embeds""": negative_image_embeds,
							    """generator""": generator,
							    """height""": 64,
							    """width""": 64,
							    """num_inference_steps""": 10,
							    """guidance_scale""": 7.0,
							    """strength""": 0.2,
							    """output_type""": """np""",
							}
							return inputs



					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				str		=			"""cpu"""

							SCREAMING_SNAKE_CASE :				int		=			self.get_dummy_components()

							SCREAMING_SNAKE_CASE :				int		=			self.pipeline_class(**lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Dict		=			pipe.to(lowerCamelCase_						)

							pipe.set_progress_bar_config(disable=lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Any		=			pipe(**self.get_dummy_inputs(lowerCamelCase_						)						)
							SCREAMING_SNAKE_CASE :				Tuple		=			output.images

							SCREAMING_SNAKE_CASE :				List[str]		=			pipe(
							    **self.get_dummy_inputs(lowerCamelCase_						)      ,						return_dict=lowerCamelCase_      ,						)[0]

							SCREAMING_SNAKE_CASE :				List[Any]		=			image[0, -3:, -3:, -1]
							SCREAMING_SNAKE_CASE :				str		=			image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			np.array(
							    [0.61_474_943, 0.6_073_539, 0.43_308_544, 0.5_928_269, 0.47_493_595, 0.46_755_973, 0.4_613_838, 0.45_368_797, 0.50_119_233]						)
							assert (
							    np.abs(image_slice.flatten() - expected_slice						).max() < 1e-2
							), f''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
							assert (
							    np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1e-2
							), f''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''







@slow
@require_torch_gpu
class      UpperCamelCase__					(					unittest.TestCase			):




					"""simple docstring"""


					def lowerCamelCase_			(						self				:			Union[str, Any]						):

							'''simple docstring'''



							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[int]		=			load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/kandinsky/kandinsky_img2img_frog.npy"""						)

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png"""						)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			"""A red cartoon frog, 4k"""

							SCREAMING_SNAKE_CASE :				int		=			KandinskyPriorPipeline.from_pretrained(
							    """kandinsky-community/kandinsky-2-1-prior"""      ,						torch_dtype=torch.floataa						)
							pipe_prior.to(lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				str		=			KandinskyImgaImgPipeline.from_pretrained(
							    """kandinsky-community/kandinsky-2-1"""      ,						torch_dtype=torch.floataa						)
							SCREAMING_SNAKE_CASE :				Dict		=			pipeline.to(lowerCamelCase_						)

							pipeline.set_progress_bar_config(disable=lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Optional[int]		=			torch.Generator(device="""cpu"""						).manual_seed(0						)
							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE :				Dict		=			pipe_prior(
							    lowerCamelCase_      ,						generator=lowerCamelCase_      ,						num_inference_steps=5      ,						negative_prompt=""""""      ,						).to_tuple()

							SCREAMING_SNAKE_CASE :				Dict		=			pipeline(
							    lowerCamelCase_      ,						image=lowerCamelCase_      ,						image_embeds=lowerCamelCase_      ,						negative_image_embeds=lowerCamelCase_      ,						generator=lowerCamelCase_      ,						num_inference_steps=1_00      ,						height=7_68      ,						width=7_68      ,						strength=0.2      ,						output_type="""np"""      ,						)

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			output.images[0]

							assert image.shape == (7_68, 7_68, 3)

							assert_mean_pixel_difference(lowerCamelCase_      ,						lowerCamelCase_						)










'''simple docstring'''




import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase            =       """▁"""

__UpperCAmelCase            =       get_tests_dir("""fixtures/test_sentencepiece.model""")




@require_sentencepiece
@require_tokenizers
class      UpperCamelCase__					(					lowercase_						,					unittest.TestCase			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	BigBirdTokenizer
					SCREAMING_SNAKE_CASE__				=	BigBirdTokenizerFast
					SCREAMING_SNAKE_CASE__				=	True
					SCREAMING_SNAKE_CASE__				=	True


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							super().setUp()

							SCREAMING_SNAKE_CASE :				List[Any]		=			self.tokenizer_class(lowerCamelCase_      ,						keep_accents=lowerCamelCase_						)
							tokenizer.save_pretrained(self.tmpdirname						)


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			"""<s>"""
							SCREAMING_SNAKE_CASE :				str		=			1

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


					def lowerCamelCase_			(						self				:			List[str]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[Any]		=			list(self.get_tokenizer().get_vocab().keys()						)

							self.assertEqual(vocab_keys[0]      ,						"""<unk>"""						)
							self.assertEqual(vocab_keys[1]      ,						"""<s>"""						)
							self.assertEqual(vocab_keys[-1]      ,						"""[MASK]"""						)
							self.assertEqual(len(lowerCamelCase_						)      ,						10_04						)


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							self.assertEqual(self.get_tokenizer().vocab_size      ,						10_00						)


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							if not self.test_rust_tokenizer:
									return

							SCREAMING_SNAKE_CASE :				List[Any]		=			self.get_tokenizer()
							SCREAMING_SNAKE_CASE :				str		=			self.get_rust_tokenizer()

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			"""I was born in 92000, and this is falsé."""

							SCREAMING_SNAKE_CASE :				Tuple		=			tokenizer.tokenize(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				List[Any]		=			rust_tokenizer.tokenize(lowerCamelCase_						)
							self.assertListEqual(lowerCamelCase_      ,						lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				int		=			tokenizer.encode(lowerCamelCase_      ,						add_special_tokens=lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			rust_tokenizer.encode(lowerCamelCase_      ,						add_special_tokens=lowerCamelCase_						)
							self.assertListEqual(lowerCamelCase_      ,						lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				List[str]		=			self.get_rust_tokenizer()
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			tokenizer.encode(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			rust_tokenizer.encode(lowerCamelCase_						)
							self.assertListEqual(lowerCamelCase_      ,						lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				int		=			BigBirdTokenizer(lowerCamelCase_      ,						keep_accents=lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				int		=			tokenizer.tokenize("""This is a test"""						)
							self.assertListEqual(lowerCamelCase_      ,						["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]						)

							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(lowerCamelCase_						)      ,						[2_85, 46, 10, 1_70, 3_82]      ,						)

							SCREAMING_SNAKE_CASE :				List[Any]		=			tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
							self.assertListEqual(
							    lowerCamelCase_      ,						[
							        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""",
							        """é""",
							        """.""",
							    ]      ,						)
							SCREAMING_SNAKE_CASE :				int		=			tokenizer.convert_tokens_to_ids(lowerCamelCase_						)
							self.assertListEqual(
							    lowerCamelCase_      ,						[8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]      ,						)

							SCREAMING_SNAKE_CASE :				int		=			tokenizer.convert_ids_to_tokens(lowerCamelCase_						)
							self.assertListEqual(
							    lowerCamelCase_      ,						[
							        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>""",
							        """.""",
							    ]      ,						)


					@cached_property
					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''simple docstring'''



							return BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""						)


					@slow
					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[str]		=			"""Hello World!"""
							SCREAMING_SNAKE_CASE :				Tuple		=			[65, 1_85_36, 22_60, 1_01, 66]

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


					@slow
					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			(
							    """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"""
							)
							# fmt: off
							SCREAMING_SNAKE_CASE :				Dict		=			[65, 8_71, 4_19, 3_58, 9_46, 9_91, 25_21, 4_52, 3_58, 13_57, 3_87, 77_51, 35_36, 1_12, 9_85, 4_56, 1_26, 8_65, 9_38, 54_00, 57_34, 4_58, 13_68, 4_67, 7_86, 24_62, 52_46, 11_59, 6_33, 8_65, 45_19, 4_57, 5_82, 8_52, 25_57, 4_27, 9_16, 5_08, 4_05, 3_43_24, 4_97, 3_91, 4_08, 1_13_42, 12_44, 3_85, 1_00, 9_38, 9_85, 4_56, 5_74, 3_62, 1_25_97, 32_00, 31_29, 11_72, 66]  # noqa: E231
							# fmt: on
							self.assertListEqual(lowerCamelCase_      ,						self.big_tokenizer.encode(lowerCamelCase_						)						)


					@require_torch
					@slow
					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''simple docstring'''



							import torch

							from transformers import BigBirdConfig, BigBirdModel

							# Build sequence
							SCREAMING_SNAKE_CASE :				int		=			list(self.big_tokenizer.get_vocab().keys()						)[:10]
							SCREAMING_SNAKE_CASE :				List[str]		=			""" """.join(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				int		=			self.big_tokenizer.encode_plus(lowerCamelCase_      ,						return_tensors="""pt"""      ,						return_token_type_ids=lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Any		=			self.big_tokenizer.batch_encode_plus(
							    [sequence + """ """ + sequence]      ,						return_tensors="""pt"""      ,						return_token_type_ids=lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Dict		=			BigBirdConfig(attention_type="""original_full"""						)
							SCREAMING_SNAKE_CASE :				Tuple		=			BigBirdModel(lowerCamelCase_						)

							assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

							with torch.no_grad():
									model(**lowerCamelCase_						)
									model(**lowerCamelCase_						)


					@slow
					def lowerCamelCase_			(						self				:			List[str]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""						)
							SCREAMING_SNAKE_CASE :				List[Any]		=			tokenizer.decode(tokenizer("""Paris is the [MASK]."""						).input_ids						)

							self.assertTrue(decoded_text == """[CLS] Paris is the[MASK].[SEP]"""						)



					@slow
					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[int]		=			{"""input_ids""": [[65, 3_92_86, 4_58, 3_63_35, 20_01, 4_56, 1_30_73, 1_32_66, 4_55, 1_13, 77_46, 17_41, 1_11_57, 3_91, 1_30_73, 1_32_66, 4_55, 1_13, 39_67, 3_54_12, 1_13, 49_36, 1_09, 38_70, 23_77, 1_13, 3_00_84, 4_57_20, 4_58, 1_34, 1_74_96, 1_12, 5_03, 1_16_72, 1_13, 1_18, 1_12, 56_65, 1_33_47, 3_86_87, 1_12, 14_96, 3_13_89, 1_12, 32_68, 4_72_64, 1_34, 9_62, 1_12, 1_63_77, 80_35, 2_31_30, 4_30, 1_21_69, 1_55_18, 2_85_92, 4_58, 1_46, 4_16_97, 1_09, 3_91, 1_21_69, 1_55_18, 1_66_89, 4_58, 1_46, 4_13_58, 1_09, 4_52, 7_26, 40_34, 1_11, 7_63, 3_54_12, 50_82, 3_88, 19_03, 1_11, 90_51, 3_91, 28_70, 4_89_18, 19_00, 11_23, 5_50, 9_98, 1_12, 95_86, 1_59_85, 4_55, 3_91, 4_10, 2_29_55, 3_76_36, 1_14, 66], [65, 4_48, 1_74_96, 4_19, 36_63, 3_85, 7_63, 1_13, 2_75_33, 28_70, 32_83, 1_30_43, 16_39, 2_47_13, 5_23, 6_56, 2_40_13, 1_85_50, 25_21, 5_17, 2_70_14, 2_12_44, 4_20, 12_12, 14_65, 3_91, 9_27, 48_33, 3_88, 5_78, 1_17_86, 1_14, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 4_84, 21_69, 76_87, 2_19_32, 1_81_46, 7_26, 3_63, 1_70_32, 33_91, 1_14, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 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], [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]]}  # noqa: E501
							# fmt: on

							self.tokenizer_integration_test_util(
							    expected_encoding=lowerCamelCase_      ,						model_name="""google/bigbird-roberta-base"""      ,						revision="""215c99f1600e06f83acce68422f2035b2b5c3510"""      ,						)



