

'''simple docstring'''







import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


__lowerCamelCase						    =      logging.get_logger(__name__)  # pylint: disable=invalid-name


class    A__ ( _snake_case     ):



    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			)  -> Union[str, Any]:





           '''simple docstring'''
           super().__init__()
           self.register_modules(
               vae=UpperCamelCase__						,			text_encoder=UpperCamelCase__						,			tokenizer=UpperCamelCase__						,			unet=UpperCamelCase__						,			scheduler=UpperCamelCase__						,			safety_checker=UpperCamelCase__						,			feature_extractor=UpperCamelCase__						,			)



    def    snake_case_     (   self						,			UpperCamelCase__ = "auto"    )  -> Any:





           '''simple docstring'''
           if slice_size == "auto":
                  # half the attention head size is usually a good trade-off between
                  # speed and memory
                  A_		   = self.unet.config.attention_head_dim // 2
           self.unet.set_attention_slice(UpperCamelCase__    )



    def    snake_case_     (   self    )  -> List[Any]:





           '''simple docstring'''
           self.enable_attention_slicing(UpperCamelCase__    )







    @torch.no_grad()
    def __call__(   self						,			UpperCamelCase__						,			UpperCamelCase__ = 512						,			UpperCamelCase__ = 512						,			UpperCamelCase__ = 50						,			UpperCamelCase__ = 7.5						,			UpperCamelCase__ = None						,			UpperCamelCase__ = 1						,			UpperCamelCase__ = 0.0						,			UpperCamelCase__ = None						,			UpperCamelCase__ = None						,			UpperCamelCase__ = "pil"						,			UpperCamelCase__ = True						,			UpperCamelCase__ = None						,			UpperCamelCase__ = 1						,			UpperCamelCase__ = None						,			**UpperCamelCase__						,			)  -> Tuple:





           '''simple docstring'''

           if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = 1
           elif isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = len(UpperCamelCase__    )
           else:
                  raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(UpperCamelCase__    )}'''    )

           if height % 8 != 0 or width % 8 != 0:
                  raise ValueError(f'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''    )

           if (callback_steps is None) or (
               callback_steps is not None and (not isinstance(UpperCamelCase__						,			UpperCamelCase__    ) or callback_steps <= 0)
           ):
                  raise ValueError(
                      f'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
                      f''' {type(UpperCamelCase__    )}.'''    )

           # get prompt text embeddings
           A_		   = self.tokenizer(
               UpperCamelCase__						,			padding="""max_length"""						,			max_length=self.tokenizer.model_max_length						,			return_tensors="""pt"""						,			)
           A_		   = text_inputs.input_ids

           if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
                  A_		   = self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]    )
                  logger.warning(
                      """The following part of your input was truncated because CLIP can only handle sequences up to"""
                      f''' {self.tokenizer.model_max_length} tokens: {removed_text}'''    )
                  A_		   = text_input_ids[:, : self.tokenizer.model_max_length]

           if text_embeddings is None:
                  A_		   = self.text_encoder(text_input_ids.to(self.device    )    )[0]

           # duplicate text embeddings for each generation per prompt, using mps friendly method
           A_   ,     A_   ,     A_		   = text_embeddings.shape
           A_		   = text_embeddings.repeat(1						,			UpperCamelCase__						,			1    )
           A_		   = text_embeddings.view(bs_embed * num_images_per_prompt						,			UpperCamelCase__						,			-1    )

           # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
           # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
           # corresponds to doing no classifier free guidance.
           A_		   = guidance_scale > 1.0
           # get unconditional embeddings for classifier free guidance
           if do_classifier_free_guidance:
                  A_		   = 42
                  if negative_prompt is None:
                         A_		   = [""""""]
                  elif type(UpperCamelCase__    ) is not type(UpperCamelCase__    ):
                         raise TypeError(
                             f'''`negative_prompt` should be the same type to `prompt`, but got {type(UpperCamelCase__    )} !='''
                             f''' {type(UpperCamelCase__    )}.'''    )
                  elif isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                         A_		   = [negative_prompt]
                  elif batch_size != len(UpperCamelCase__    ):
                         raise ValueError(
                             f'''`negative_prompt`: {negative_prompt} has batch size {len(UpperCamelCase__    )}, but `prompt`:'''
                             f''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
                             """ the batch size of `prompt`."""    )
                  else:
                         A_		   = negative_prompt

                  A_		   = text_input_ids.shape[-1]
                  A_		   = self.tokenizer(
                      UpperCamelCase__						,			padding="""max_length"""						,			max_length=UpperCamelCase__						,			truncation=UpperCamelCase__						,			return_tensors="""pt"""						,			)
                  A_		   = self.text_encoder(uncond_input.input_ids.to(self.device    )    )[0]

                  # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
                  A_		   = uncond_embeddings.shape[1]
                  A_		   = uncond_embeddings.repeat(UpperCamelCase__						,			UpperCamelCase__						,			1    )
                  A_		   = uncond_embeddings.view(batch_size * num_images_per_prompt						,			UpperCamelCase__						,			-1    )

                  # For classifier free guidance, we need to do two forward passes.
                  # Here we concatenate the unconditional and text embeddings into a single batch
                  # to avoid doing two forward passes
                  A_		   = torch.cat([uncond_embeddings, text_embeddings]    )

           # get the initial random noise unless the user supplied it

           # Unlike in other pipelines, latents need to be generated in the target device
           # for 1-to-1 results reproducibility with the CompVis implementation.
           # However this currently doesn't work in `mps`.
           A_		   = (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
           A_		   = (batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
           A_		   = text_embeddings.dtype
           if latents is None:
                  if self.device.type == "mps":
                         # randn does not exist on mps
                         A_		   = torch.randn(
                             UpperCamelCase__						,			generator=UpperCamelCase__						,			device="""cpu"""						,			dtype=UpperCamelCase__    ).to(self.device    )
                         A_		   = torch.randn(UpperCamelCase__						,			generator=UpperCamelCase__						,			device="""cpu"""						,			dtype=UpperCamelCase__    ).to(
                             self.device    )
                  else:
                         A_		   = torch.randn(
                             UpperCamelCase__						,			generator=UpperCamelCase__						,			device=self.device						,			dtype=UpperCamelCase__    )
                         A_		   = torch.randn(UpperCamelCase__						,			generator=UpperCamelCase__						,			device=self.device						,			dtype=UpperCamelCase__    )
           else:
                  if latents_reference.shape != latents_shape:
                         raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''    )
                  A_		   = latents_reference.to(self.device    )
                  A_		   = latents.to(self.device    )

           # This is the key part of the pipeline where we
           # try to ensure that the generated images w/ the same seed
           # but different sizes actually result in similar images
           A_		   = (latents_shape[3] - latents_shape_reference[3]) // 2
           A_		   = (latents_shape[2] - latents_shape_reference[2]) // 2
           A_		   = latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
           A_		   = latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
           A_		   = 0 if dx < 0 else dx
           A_		   = 0 if dy < 0 else dy
           A_		   = max(-dx						,			0    )
           A_		   = max(-dy						,			0    )
           # import pdb
           # pdb.set_trace()
           A_		   = latents_reference[:, :, dy : dy + h, dx : dx + w]

           # set timesteps
           self.scheduler.set_timesteps(UpperCamelCase__    )

           # Some schedulers like PNDM have timesteps as arrays
           # It's more optimized to move all timesteps to correct device beforehand
           A_		   = self.scheduler.timesteps.to(self.device    )

           # scale the initial noise by the standard deviation required by the scheduler
           A_		   = latents * self.scheduler.init_noise_sigma

           # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
           # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
           # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
           # and should be between [0, 1]
           A_		   = """eta""" in set(inspect.signature(self.scheduler.step    ).parameters.keys()    )
           A_		   = {}
           if accepts_eta:
                  A_		   = eta

           for i, t in enumerate(self.progress_bar(UpperCamelCase__    )    ):
                  # expand the latents if we are doing classifier free guidance
                  A_		   = torch.cat([latents] * 2    ) if do_classifier_free_guidance else latents
                  A_		   = self.scheduler.scale_model_input(UpperCamelCase__						,			UpperCamelCase__    )

                  # predict the noise residual
                  A_		   = self.unet(UpperCamelCase__						,			UpperCamelCase__						,			encoder_hidden_states=UpperCamelCase__    ).sample

                  # perform guidance
                  if do_classifier_free_guidance:
                         A_   ,     A_		   = noise_pred.chunk(2    )
                         A_		   = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                  # compute the previous noisy sample x_t -> x_t-1
                  A_		   = self.scheduler.step(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			**UpperCamelCase__    ).prev_sample

                  # call the callback, if provided
                  if callback is not None and i % callback_steps == 0:
                         callback(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )

           A_		   = 1 / 0.18215 * latents
           A_		   = self.vae.decode(UpperCamelCase__    ).sample

           A_		   = (image / 2 + 0.5).clamp(0						,			1    )

           # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
           A_		   = image.cpu().permute(0						,			2						,			3						,			1    ).float().numpy()

           if self.safety_checker is not None:
                  A_		   = self.feature_extractor(self.numpy_to_pil(UpperCamelCase__    )						,			return_tensors="""pt"""    ).to(
                      self.device    )
                  A_   ,     A_		   = self.safety_checker(
                      images=UpperCamelCase__						,			clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype    )    )
           else:
                  A_		   = None

           if output_type == "pil":
                  A_		   = self.numpy_to_pil(UpperCamelCase__    )

           if not return_dict:
                  return (image, has_nsfw_concept)

           return StableDiffusionPipelineOutput(images=UpperCamelCase__						,			nsfw_content_detected=UpperCamelCase__    )



'''simple docstring'''







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


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


@require_sentencepiece
@require_tokenizers
class    A__ ( _snake_case  ,  unittest.TestCase     ):
    lowercase		   =						ReformerTokenizer
    lowercase		   =						ReformerTokenizerFast
    lowercase		   =						True
    lowercase		   =						False
    lowercase		   =						True



    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           super().setUp()

           A_		   = ReformerTokenizer(UpperCamelCase__						,			keep_accents=UpperCamelCase__    )
           tokenizer.save_pretrained(self.tmpdirname    )



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





           '''simple docstring'''
           A_		   = """<s>"""
           A_		   = 1

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



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_		   = 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(UpperCamelCase__    )						,			1000    )



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           self.assertEqual(self.get_tokenizer().vocab_size						,			1000    )



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





           '''simple docstring'''
           if not self.test_rust_tokenizer:
                  return

           A_		   = self.get_tokenizer()
           A_		   = self.get_rust_tokenizer()

           A_		   = """I was born in 92000, and this is falsé."""

           A_		   = tokenizer.tokenize(UpperCamelCase__    )
           A_		   = rust_tokenizer.tokenize(UpperCamelCase__    )
           self.assertListEqual(UpperCamelCase__						,			UpperCamelCase__    )

           A_		   = tokenizer.encode(UpperCamelCase__						,			add_special_tokens=UpperCamelCase__    )
           A_		   = rust_tokenizer.encode(UpperCamelCase__						,			add_special_tokens=UpperCamelCase__    )
           self.assertListEqual(UpperCamelCase__						,			UpperCamelCase__    )

           A_		   = self.get_rust_tokenizer()
           A_		   = tokenizer.encode(UpperCamelCase__    )
           A_		   = rust_tokenizer.encode(UpperCamelCase__    )
           self.assertListEqual(UpperCamelCase__						,			UpperCamelCase__    )



    def    snake_case_     (   self						,			UpperCamelCase__=15    )  -> int:





           '''simple docstring'''
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                  with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
                         A_		   = self.rust_tokenizer_class.from_pretrained(UpperCamelCase__						,			**UpperCamelCase__    )

                         # Simple input
                         A_		   = """This is a simple input"""
                         A_		   = ["""This is a simple input 1""", """This is a simple input 2"""]
                         A_		   = ("""This is a simple input""", """This is a pair""")
                         A_		   = [
                             ("""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(UpperCamelCase__						,			tokenizer_r.encode						,			UpperCamelCase__						,			max_length=UpperCamelCase__						,			padding="""max_length"""    )

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

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

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

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

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



    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           pass



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





           '''simple docstring'''
           A_		   = ReformerTokenizer(UpperCamelCase__						,			keep_accents=UpperCamelCase__    )

           A_		   = tokenizer.tokenize("""This is a test"""    )
           self.assertListEqual(UpperCamelCase__						,			["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]    )

           self.assertListEqual(
               tokenizer.convert_tokens_to_ids(UpperCamelCase__    )						,			[285, 46, 10, 170, 382]						,			)

           A_		   = tokenizer.tokenize("""I was born in 92000, and this is falsé."""    )
           self.assertListEqual(
               UpperCamelCase__						,			[
                   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""",
                   """é""",
                   """.""",
               ]						,			)
           A_		   = tokenizer.convert_tokens_to_ids(UpperCamelCase__    )
           self.assertListEqual(
               UpperCamelCase__						,			[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]						,			)

           A_		   = tokenizer.convert_ids_to_tokens(UpperCamelCase__    )
           self.assertListEqual(
               UpperCamelCase__						,			[
                   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    snake_case_     (   self    )  -> Optional[int]:





           '''simple docstring'''
           return ReformerTokenizer.from_pretrained("""google/reformer-crime-and-punishment"""    )



    @slow
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = """Hello World!"""
           A_		   = [126, 32, 262, 152, 38, 72, 287]

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



    @slow
    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = (
               """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"""
           )
           A_		   = [
               108,
               265,
               24,
               111,
               4,
               258,
               156,
               35,
               28,
               275,
               3,
               259,
               297,
               260,
               84,
               4,
               35,
               110,
               44,
               8,
               259,
               91,
               268,
               21,
               11,
               209,
               274,
               109,
               266,
               277,
               117,
               86,
               93,
               315,
               258,
               278,
               258,
               277,
               258,
               0,
               258,
               288,
               258,
               319,
               258,
               0,
               258,
               0,
               258,
               0,
               258,
               0,
               258,
               287,
               258,
               315,
               258,
               289,
               258,
               278,
               99,
               269,
               266,
               262,
               8,
               259,
               241,
               4,
               217,
               230,
               268,
               266,
               55,
               168,
               106,
               75,
               193,
               266,
               223,
               27,
               49,
               26,
               282,
               25,
               264,
               299,
               19,
               26,
               0,
               258,
               277,
               117,
               86,
               93,
               176,
               183,
               270,
               11,
               262,
               42,
               61,
               265,
           ]

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



    @require_torch
    @slow
    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           import torch

           from transformers import ReformerConfig, ReformerModel

           # Build sequence
           A_		   = list(self.big_tokenizer.get_vocab().keys()    )[:10]
           A_		   = """ """.join(UpperCamelCase__    )
           A_		   = self.big_tokenizer.encode_plus(UpperCamelCase__						,			return_tensors="""pt"""    )
           A_		   = self.big_tokenizer.batch_encode_plus([sequence, sequence]						,			return_tensors="""pt"""    )

           A_		   = ReformerConfig()
           # The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
           A_		   = encoded_sequence["""input_ids"""].shape
           A_		   = ReformerModel(UpperCamelCase__    )

           # 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(**UpperCamelCase__    )
                  model(**UpperCamelCase__    )







    @slow
    def    snake_case_     (   self    )  -> Optional[int]:





           '''simple docstring'''
           # fmt: off
           A_		   = {"""input_ids""": [[108, 265, 24, 111, 4, 258, 156, 7, 51, 279, 58, 7, 76, 25, 69, 278], [140, 243, 264, 134, 17, 267, 77, 263, 22, 262, 297, 258, 304, 177, 279, 266, 14, 89, 13, 35, 261, 299, 272, 137, 275, 278]], """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
           A_		   = [
               """This is a very simple sentence.""",
               """The quick brown fox jumps over the lazy dog.""",
           ]

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