


from typing import List, Optional, Union

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

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


_lowerCAmelCase:						Union[str, Any]   				=       logging.get_logger(__name__)  # pylint: disable=invalid-name

_lowerCAmelCase:						Optional[Any]   				=       '\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n        >>> from diffusers.utils import load_image\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n        ...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16\n        ... )\n        >>> pipe_prior.to("cuda")\n\n        >>> prompt = "A red cartoon frog, 4k"\n        >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n        >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n        ...     "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16\n        ... )\n        >>> pipe.to("cuda")\n\n        >>> init_image = load_image(\n        ...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"\n        ...     "/kandinsky/frog.png"\n        ... )\n\n        >>> image = pipe(\n        ...     image=init_image,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ...     strength=0.2,\n        ... ).images\n\n        >>> image[0].save("red_frog.png")\n        ```\n'






def   _lowercase(					__a				:						Any    ,     __a				:						int    ,     __a				:						str=8     ):
							a__      =height // scale_factor**2
							if height % scale_factor**2 != 0:
														new_height += 1
							a__      =width // scale_factor**2
							if width % scale_factor**2 != 0:
														new_width += 1
							return new_height * scale_factor, new_width * scale_factor






def   _lowercase(					__a				:						Tuple    ,     __a				:						Optional[Any]=512    ,     __a				:						Any=512     ):
							a__      =pil_image.resize((w, h)    ,     resample=Image.BICUBIC    ,     reducing_gap=1     )
							a__      =np.array(pil_image.convert('RGB'     )     )
							a__      =arr.astype(np.floataa     ) / 1_27.5 - 1
							a__      =np.transpose(__a    ,     [2, 0, 1]     )
							a__      =torch.from_numpy(__a     ).unsqueeze(0     )
							return image







class       lowercase_					(lowercase__   ):





				def __init__(				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  )  -> Any:
											super().__init__()

											self.register_modules(
											    unet=lowercase_       ,  scheduler=lowercase_       ,  movq=lowercase_       ,  )
											a__      =2 ** (len(self.movq.config.block_out_channels) - 1)





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_)  -> str:
											# get the original timestep using init_timestep
											a__      =min(int(num_inference_steps * strength)       ,  lowercase_)

											a__      =max(num_inference_steps - init_timestep       ,  0)
											a__      =self.scheduler.timesteps[t_start:]

											return timesteps, num_inference_steps - t_start





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_=None)  -> Union[str, Any]:
											if not isinstance(lowercase_       ,  (torch.Tensor, PIL.Image.Image, list)):
																		raise ValueError(
																		    F"""`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(lowercase_)}""")

											a__      =image.to(device=lowercase_       ,  dtype=lowercase_)

											a__      =batch_size * num_images_per_prompt

											if image.shape[1] == 4:
																		a__      =image

											else:
																		if isinstance(lowercase_       ,  lowercase_) and len(lowercase_) != batch_size:
																									raise ValueError(
																									    F"""You have passed a list of generators of length {len(lowercase_)}, but requested an effective batch"""
																									    F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""")

																		elif isinstance(lowercase_       ,  lowercase_):
																									a__      =[
																									    self.movq.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowercase_)
																									]
																									a__      =torch.cat(lowercase_       ,  dim=0)
																		else:
																									a__      =self.movq.encode(lowercase_).latent_dist.sample(lowercase_)

																		a__      =self.movq.config.scaling_factor * init_latents

											a__      =torch.cat([init_latents]       ,  dim=0)

											a__      =init_latents.shape
											a__      =randn_tensor(lowercase_       ,  generator=lowercase_       ,  device=lowercase_       ,  dtype=lowercase_)

											# get latents
											a__      =self.scheduler.add_noise(lowercase_       ,  lowercase_       ,  lowercase_)

											a__      =init_latents

											return latents





				def 						__UpperCamelCase    (				self       ,  lowercase_=0)  -> str:
											if is_accelerate_available():
																		from accelerate import cpu_offload
											else:
																		raise ImportError('Please install accelerate via `pip install accelerate`')

											a__      =torch.device(F"""cuda:{gpu_id}""")

											a__      =[
											    self.unet,
											    self.movq,
											]
											for cpu_offloaded_model in models:
																		if cpu_offloaded_model is not None:
																									cpu_offload(lowercase_       ,  lowercase_)





				def 						__UpperCamelCase    (				self       ,  lowercase_=0)  -> List[Any]:
											if is_accelerate_available() and is_accelerate_version('>='       ,  '0.17.0.dev0'):
																		from accelerate import cpu_offload_with_hook
											else:
																		raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.')

											a__      =torch.device(F"""cuda:{gpu_id}""")

											if self.device.type != "cpu":
																		self.to('cpu'       ,  silence_dtype_warnings=lowercase_)
																		torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

											a__      =None
											for cpu_offloaded_model in [self.unet, self.movq]:
																		a__    ,     a__      =cpu_offload_with_hook(lowercase_       ,  lowercase_       ,  prev_module_hook=lowercase_)

											# We'll offload the last model manually.
											a__      =hook





				@property
				# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
				def 						__UpperCamelCase    (				self)  -> List[Any]:
											if not hasattr(self.unet       ,  '_hf_hook'):
																		return self.device
											for module in self.unet.modules():
																		if (
																		    hasattr(lowercase_       ,  '_hf_hook')
																		    and hasattr(module._hf_hook       ,  'execution_device')
																		    and module._hf_hook.execution_device is not None
																		):
																									return torch.device(module._hf_hook.execution_device)
											return self.device





				@torch.no_grad()
				@replace_example_docstring(lowercase_)
				def __call__(				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_ = 512       ,  lowercase_ = 512       ,  lowercase_ = 100       ,  lowercase_ = 4.0       ,  lowercase_ = 0.3       ,  lowercase_ = 1       ,  lowercase_ = None       ,  lowercase_ = "pil"       ,  lowercase_ = True       ,  )  -> Optional[int]:
											a__      =self._execution_device

											a__      =guidance_scale > 1.0

											if isinstance(lowercase_       ,  lowercase_):
																		a__      =torch.cat(lowercase_       ,  dim=0)
											a__      =image_embeds.shape[0]
											if isinstance(lowercase_       ,  lowercase_):
																		a__      =torch.cat(lowercase_       ,  dim=0)

											if do_classifier_free_guidance:
																		a__      =image_embeds.repeat_interleave(lowercase_       ,  dim=0)
																		a__      =negative_image_embeds.repeat_interleave(lowercase_       ,  dim=0)

											a__      =torch.cat([negative_image_embeds, image_embeds]       ,  dim=0).to(dtype=self.unet.dtype       ,  device=lowercase_)

											if not isinstance(lowercase_       ,  lowercase_):
																		a__      =[image]
											if not all(isinstance(lowercase_       ,  (PIL.Image.Image, torch.Tensor)) for i in image):
																		raise ValueError(
																		    F"""Input is in incorrect format: {[type(lowercase_) for i in image]}. Currently, we only support  PIL image and pytorch tensor""")

											a__      =torch.cat([prepare_image(lowercase_       ,  lowercase_       ,  lowercase_) for i in image]       ,  dim=0)
											a__      =image.to(dtype=image_embeds.dtype       ,  device=lowercase_)

											a__      =self.movq.encode(lowercase_)['latents']
											a__      =latents.repeat_interleave(lowercase_       ,  dim=0)
											self.scheduler.set_timesteps(lowercase_       ,  device=lowercase_)
											a__    ,     a__      =self.get_timesteps(lowercase_       ,  lowercase_       ,  lowercase_)
											a__      =timesteps[:1].repeat(batch_size * num_images_per_prompt)
											a__    ,     a__      =downscale_height_and_width(lowercase_       ,  lowercase_       ,  self.movq_scale_factor)
											a__      =self.prepare_latents(
											    lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  image_embeds.dtype       ,  lowercase_       ,  lowercase_)
											for i, t in enumerate(self.progress_bar(lowercase_)):
																		# expand the latents if we are doing classifier free guidance
																		a__      =torch.cat([latents] * 2) if do_classifier_free_guidance else latents

																		a__      ={'image_embeds': image_embeds}
																		a__      =self.unet(
																		    sample=lowercase_       ,  timestep=lowercase_       ,  encoder_hidden_states=lowercase_       ,  added_cond_kwargs=lowercase_       ,  return_dict=lowercase_       ,  )[0]

																		if do_classifier_free_guidance:
																									a__    ,     a__      =noise_pred.split(latents.shape[1]       ,  dim=1)
																									a__    ,     a__      =noise_pred.chunk(2)
																									a__    ,     a__      =variance_pred.chunk(2)
																									a__      =noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																									a__      =torch.cat([noise_pred, variance_pred_text]       ,  dim=1)

																		if not (
																		    hasattr(self.scheduler.config       ,  'variance_type')
																		    and self.scheduler.config.variance_type in ["learned", "learned_range"]
																		):
																									a__    ,     a__      =noise_pred.split(latents.shape[1]       ,  dim=1)

																		# compute the previous noisy sample x_t -> x_t-1
																		a__      =self.scheduler.step(
																		    lowercase_       ,  lowercase_       ,  lowercase_       ,  generator=lowercase_       ,  )[0]

											# post-processing
											a__      =self.movq.decode(lowercase_       ,  force_not_quantize=lowercase_)['sample']

											if output_type not in ["pt", "np", "pil"]:
																		raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}""")

											if output_type in ["np", "pil"]:
																		a__      =image * 0.5 + 0.5
																		a__      =image.clamp(0       ,  1)
																		a__      =image.cpu().permute(0       ,  2       ,  3       ,  1).float().numpy()

											if output_type == "pil":
																		a__      =self.numpy_to_pil(lowercase_)

											if not return_dict:
																		return (image,)

											return ImagePipelineOutput(images=lowercase_)



import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
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


lowercase    :   List[str]						=			get_tests_dir('fixtures/test_sentencepiece.model')




@require_sentencepiece
@require_tokenizers
class 					lowerCamelCase__				(							__lowercase	,		unittest.TestCase):




	'''simple docstring'''




	_A								=	ReformerTokenizer
	_A								=	ReformerTokenizerFast
	_A								=	True
	_A								=	False
	_A								=	True







	def   _lowerCamelCase							(   self						:Dict		)						->					Union[str, Any]:
								super().setUp()

								__UpperCamelCase      :  List[str]       =   ReformerTokenizer(a	,  keep_accents=a		)
								tokenizer.save_pretrained(self.tmpdirname		)







	def   _lowerCamelCase							(   self						:Union[str, Any]		)						->					Dict:
								__UpperCamelCase      :  int       =   "<s>"
								__UpperCamelCase      :  Dict       =   1

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







	def   _lowerCamelCase							(   self						:Dict		)						->					List[Any]:
								__UpperCamelCase      :  int       =   list(self.get_tokenizer().get_vocab().keys()		)

								self.assertEqual(vocab_keys[0]	,  "<unk>"		)
								self.assertEqual(vocab_keys[1]	,  "<s>"		)
								self.assertEqual(vocab_keys[-1]	,  "j"		)
								self.assertEqual(len(a		)	,  1_0_0_0		)







	def   _lowerCamelCase							(   self						:List[str]		)						->					str:
								self.assertEqual(self.get_tokenizer().vocab_size	,  1_0_0_0		)







	def   _lowerCamelCase							(   self						:List[str]		)						->					List[str]:
								if not self.test_rust_tokenizer:
															return

								__UpperCamelCase      :  Union[str, Any]       =   self.get_tokenizer()
								__UpperCamelCase      :  List[str]       =   self.get_rust_tokenizer()

								__UpperCamelCase      :  Union[str, Any]       =   "I was born in 92000, and this is falsé."

								__UpperCamelCase      :  List[str]       =   tokenizer.tokenize(a		)
								__UpperCamelCase      :  int       =   rust_tokenizer.tokenize(a		)
								self.assertListEqual(a	,  a		)

								__UpperCamelCase      :  List[str]       =   tokenizer.encode(a	,  add_special_tokens=a		)
								__UpperCamelCase      :  Tuple       =   rust_tokenizer.encode(a	,  add_special_tokens=a		)
								self.assertListEqual(a	,  a		)

								__UpperCamelCase      :  Union[str, Any]       =   self.get_rust_tokenizer()
								__UpperCamelCase      :  int       =   tokenizer.encode(a		)
								__UpperCamelCase      :  List[Any]       =   rust_tokenizer.encode(a		)
								self.assertListEqual(a	,  a		)







	def   _lowerCamelCase							(   self						:Tuple	,  a						:int=1_5		)						->					Any:
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
																						__UpperCamelCase      :  List[Any]       =   self.rust_tokenizer_class.from_pretrained(a	,  **a		)

																						# Simple input
																						__UpperCamelCase      :  Union[str, Any]       =   "This is a simple input"
																						__UpperCamelCase      :  Dict       =   ["This is a simple input 1", "This is a simple input 2"]
																						__UpperCamelCase      :  Tuple       =   ("This is a simple input", "This is a pair")
																						__UpperCamelCase      :  Optional[Any]       =   [
																						    ("This is a simple input 1", "This is a simple input 2"),
																						    ("This is a simple pair 1", "This is a simple pair 2"),
																						]

																						# Simple input tests
																						self.assertRaises(a	,  tokenizer_r.encode	,  a	,  max_length=a	,  padding="max_length"		)

																						# Simple input
																						self.assertRaises(a	,  tokenizer_r.encode_plus	,  a	,  max_length=a	,  padding="max_length"		)

																						# Simple input
																						self.assertRaises(
																						    a	,  tokenizer_r.batch_encode_plus	,  a	,  max_length=a	,  padding="max_length"	,  )

																						# Pair input
																						self.assertRaises(a	,  tokenizer_r.encode	,  a	,  max_length=a	,  padding="max_length"		)

																						# Pair input
																						self.assertRaises(a	,  tokenizer_r.encode_plus	,  a	,  max_length=a	,  padding="max_length"		)

																						# Pair input
																						self.assertRaises(
																						    a	,  tokenizer_r.batch_encode_plus	,  a	,  max_length=a	,  padding="max_length"	,  )







	def   _lowerCamelCase							(   self						:Union[str, Any]		)						->					str:
								pass







	def   _lowerCamelCase							(   self						:Union[str, Any]		)						->					Optional[Any]:
								__UpperCamelCase      :  List[Any]       =   ReformerTokenizer(a	,  keep_accents=a		)

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

								self.assertListEqual(
								    tokenizer.convert_tokens_to_ids(a		)	,  [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]	,  )

								__UpperCamelCase      :  str       =   tokenizer.tokenize("I was born in 92000, and this is falsé."		)
								self.assertListEqual(
								    a	,  [
								        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",
								        "é",
								        ".",
								    ]	,  )
								__UpperCamelCase      :  Union[str, Any]       =   tokenizer.convert_tokens_to_ids(a		)
								self.assertListEqual(
								    a	,  [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4]	,  )

								__UpperCamelCase      :  Union[str, Any]       =   tokenizer.convert_ids_to_tokens(a		)
								self.assertListEqual(
								    a	,  [
								        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						:Any		)						->					List[str]:
								return ReformerTokenizer.from_pretrained("google/reformer-crime-and-punishment"		)







	@slow
	def   _lowerCamelCase							(   self						:List[Any]		)						->					Dict:
								__UpperCamelCase      :  int       =   "Hello World!"
								__UpperCamelCase      :  Union[str, Any]       =   [1_2_6, 3_2, 2_6_2, 1_5_2, 3_8, 7_2, 2_8_7]

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







	@slow
	def   _lowerCamelCase							(   self						:Optional[Any]		)						->					List[str]:
								__UpperCamelCase      :  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"
								)
								__UpperCamelCase      :  List[Any]       =   [
								    1_0_8,
								    2_6_5,
								    2_4,
								    1_1_1,
								    4,
								    2_5_8,
								    1_5_6,
								    3_5,
								    2_8,
								    2_7_5,
								    3,
								    2_5_9,
								    2_9_7,
								    2_6_0,
								    8_4,
								    4,
								    3_5,
								    1_1_0,
								    4_4,
								    8,
								    2_5_9,
								    9_1,
								    2_6_8,
								    2_1,
								    1_1,
								    2_0_9,
								    2_7_4,
								    1_0_9,
								    2_6_6,
								    2_7_7,
								    1_1_7,
								    8_6,
								    9_3,
								    3_1_5,
								    2_5_8,
								    2_7_8,
								    2_5_8,
								    2_7_7,
								    2_5_8,
								    0,
								    2_5_8,
								    2_8_8,
								    2_5_8,
								    3_1_9,
								    2_5_8,
								    0,
								    2_5_8,
								    0,
								    2_5_8,
								    0,
								    2_5_8,
								    0,
								    2_5_8,
								    2_8_7,
								    2_5_8,
								    3_1_5,
								    2_5_8,
								    2_8_9,
								    2_5_8,
								    2_7_8,
								    9_9,
								    2_6_9,
								    2_6_6,
								    2_6_2,
								    8,
								    2_5_9,
								    2_4_1,
								    4,
								    2_1_7,
								    2_3_0,
								    2_6_8,
								    2_6_6,
								    5_5,
								    1_6_8,
								    1_0_6,
								    7_5,
								    1_9_3,
								    2_6_6,
								    2_2_3,
								    2_7,
								    4_9,
								    2_6,
								    2_8_2,
								    2_5,
								    2_6_4,
								    2_9_9,
								    1_9,
								    2_6,
								    0,
								    2_5_8,
								    2_7_7,
								    1_1_7,
								    8_6,
								    9_3,
								    1_7_6,
								    1_8_3,
								    2_7_0,
								    1_1,
								    2_6_2,
								    4_2,
								    6_1,
								    2_6_5,
								]

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







	@require_torch
	@slow
	def   _lowerCamelCase							(   self						:List[Any]		)						->					List[Any]:
								import torch

								from transformers import ReformerConfig, ReformerModel

								# Build sequence
								__UpperCamelCase      :  Tuple       =   list(self.big_tokenizer.get_vocab().keys()		)[:1_0]
								__UpperCamelCase      :  Union[str, Any]       =   " ".join(a		)
								__UpperCamelCase      :  Tuple       =   self.big_tokenizer.encode_plus(a	,  return_tensors="pt"		)
								__UpperCamelCase      :  Optional[int]       =   self.big_tokenizer.batch_encode_plus([sequence, sequence]	,  return_tensors="pt"		)

								__UpperCamelCase      :  Optional[Any]       =   ReformerConfig()
								# The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
								__UpperCamelCase      :  Tuple       =   encoded_sequence["input_ids"].shape
								__UpperCamelCase      :  int       =   ReformerModel(a		)

								# Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
								assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

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







	@slow
	def   _lowerCamelCase							(   self						:Optional[Any]		)						->					Any:
								# fmt: off
								__UpperCamelCase      :  Any       =   {"input_ids": [[1_0_8, 2_6_5, 2_4, 1_1_1, 4, 2_5_8, 1_5_6, 7, 5_1, 2_7_9, 5_8, 7, 7_6, 2_5, 6_9, 2_7_8], [1_4_0, 2_4_3, 2_6_4, 1_3_4, 1_7, 2_6_7, 7_7, 2_6_3, 2_2, 2_6_2, 2_9_7, 2_5_8, 3_0_4, 1_7_7, 2_7_9, 2_6_6, 1_4, 8_9, 1_3, 3_5, 2_6_1, 2_9_9, 2_7_2, 1_3_7, 2_7_5, 2_7_8]], "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]]}  # noqa: E501
								# fmt: on

								# This tokenizer does not know some characters like ")".
								# That is the reason why we use very simple texts here.
								# Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
								__UpperCamelCase      :  List[str]       =   [
								    "This is a very simple sentence.",
								    "The quick brown fox jumps over the lazy dog.",
								]

								self.tokenizer_integration_test_util(
								    expected_encoding=a	,  model_name="google/reformer-crime-and-punishment"	,  revision="0e6c3decb8211d49bf881013425dc8b0448b3f5a"	,  padding=a	,  sequences=a	,  )