
'''simple docstring'''







import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases







class 		snake_case_       (						A__						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self			,   UpperCamelCase			,   UpperCamelCase=False):
          lowerCamelCase__   ,		lowerCamelCase__   ,		lowerCamelCase__				   =      (
              filename_skip_take["filename"],
              filename_skip_take["skip"] if "skip" in filename_skip_take else None,
              filename_skip_take["take"] if "take" in filename_skip_take else None,
          )
          open(os.path.join(UpperCamelCase)			,   "wb").close()
          lowerCamelCase__				   =      pa.Table.from_pydict({"filename": [Path(UpperCamelCase).name] * 1_00})
          if take == -1:
                 lowerCamelCase__				   =      len(UpperCamelCase) - skip
          if skip is not None and take is not None:
                 lowerCamelCase__				   =      pa_table.slice(UpperCamelCase			,   UpperCamelCase)
          return pa_table







class 		snake_case_       (						A__						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "my_name"
          lowerCamelCase__				   =      SplitInfo(name="train"			,   num_examples=1_00)
          lowerCamelCase__				   =      SplitInfo(name="test"			,   num_examples=1_00)
          lowerCamelCase__				   =      [train_info, test_info]
          lowerCamelCase__				   =      SplitDict()
          split_dict.add(UpperCamelCase)
          split_dict.add(UpperCamelCase)
          lowerCamelCase__				   =      DatasetInfo(splits=UpperCamelCase)

          with tempfile.TemporaryDirectory() as tmp_dir:
                 lowerCamelCase__				   =      ReaderTest(UpperCamelCase			,   UpperCamelCase)

                 lowerCamelCase__				   =      "test[:33%]"
                 lowerCamelCase__				   =      Dataset(**reader.read(UpperCamelCase			,   UpperCamelCase			,   UpperCamelCase))
                 self.assertEqual(dset["filename"][0]			,   f"""{name}-test""")
                 self.assertEqual(dset.num_rows			,   33)
                 self.assertEqual(dset.num_columns			,   1)

                 lowerCamelCase__				   =      ["train", "test[:33%]"]
                 lowerCamelCase__				   =      [Split.TRAIN, ReadInstruction.from_spec("test[:33%]")]
                 for instructions in [instructionsa, instructionsa]:
                        lowerCamelCase__				   =      [reader.read(UpperCamelCase			,   UpperCamelCase			,   UpperCamelCase) for instr in instructions]
                        lowerCamelCase__   ,		lowerCamelCase__				   =      (Dataset(**UpperCamelCase) for dataset_kwargs in datasets_kwargs)
                        self.assertEqual(train_dset["filename"][0]			,   f"""{name}-train""")
                        self.assertEqual(train_dset.num_rows			,   1_00)
                        self.assertEqual(train_dset.num_columns			,   1)
                        self.assertIsInstance(train_dset.split			,   UpperCamelCase)
                        self.assertEqual(str(train_dset.split)			,   "train")
                        self.assertEqual(test_dset["filename"][0]			,   f"""{name}-test""")
                        self.assertEqual(test_dset.num_rows			,   33)
                        self.assertEqual(test_dset.num_columns			,   1)
                        self.assertIsInstance(test_dset.split			,   UpperCamelCase)
                        self.assertEqual(str(test_dset.split)			,   "test[:33%]")
                        del train_dset, test_dset







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "my_name"
          lowerCamelCase__				   =      SplitInfo(name="train"			,   num_examples=10_00			,   shard_lengths=[1_00] * 10)
          lowerCamelCase__				   =      [train_info]
          lowerCamelCase__				   =      SplitDict()
          split_dict.add(UpperCamelCase)
          lowerCamelCase__				   =      DatasetInfo(splits=UpperCamelCase)

          with tempfile.TemporaryDirectory() as tmp_dir:
                 lowerCamelCase__				   =      ReaderTest(UpperCamelCase			,   UpperCamelCase)

                 lowerCamelCase__				   =      "train[:33%]"
                 lowerCamelCase__				   =      Dataset(**reader.read(UpperCamelCase			,   UpperCamelCase			,   UpperCamelCase))
                 self.assertEqual(dset["filename"][0]			,   f"""{name}-train-00000-of-00010""")
                 self.assertEqual(dset["filename"][-1]			,   f"""{name}-train-00003-of-00010""")
                 self.assertEqual(dset.num_rows			,   3_30)
                 self.assertEqual(dset.num_columns			,   1)







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      SplitInfo(name="train"			,   num_examples=1_00)
          lowerCamelCase__				   =      SplitInfo(name="test"			,   num_examples=1_00)
          lowerCamelCase__				   =      SplitDict()
          split_dict.add(UpperCamelCase)
          split_dict.add(UpperCamelCase)
          lowerCamelCase__				   =      DatasetInfo(splits=UpperCamelCase)

          with tempfile.TemporaryDirectory() as tmp_dir:
                 lowerCamelCase__				   =      ReaderTest(UpperCamelCase			,   UpperCamelCase)

                 lowerCamelCase__				   =      [
                     {"filename": os.path.join(UpperCamelCase			,   "train")},
                     {"filename": os.path.join(UpperCamelCase			,   "test"), "skip": 10, "take": 10},
                 ]
                 lowerCamelCase__				   =      Dataset(**reader.read_files(UpperCamelCase			,   original_instructions="train+test[10:20]"))
                 self.assertEqual(dset.num_rows			,   1_10)
                 self.assertEqual(dset.num_columns			,   1)
                 del dset







@pytest.mark.parametrize("in_memory"      , [False, True]      )
def   lowerCAmelCase(  a__    :  Any      , a__    :  List[str]      , a__    :  List[Any]      ):







       '''simple docstring'''






       lowerCamelCase__				   =      arrow_file
       with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
              lowerCamelCase__				   =      ArrowReader.read_table(a__      , in_memory=a__      )
       assert table.shape == dataset.data.shape
       assert set(table.column_names      ) == set(dataset.data.column_names      )
       assert dict(table.to_pydict()      ) == dict(dataset.data.to_pydict()      )  # to_pydict returns OrderedDict







@pytest.mark.parametrize("in_memory"      , [False, True]      )
def   lowerCAmelCase(  a__    :  List[str]      , a__    :  Optional[Any]      , a__    :  Optional[Any]      ):







       '''simple docstring'''






       lowerCamelCase__				   =      arrow_file
       lowerCamelCase__				   =      ArrowReader(""      , a__      )
       with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
              lowerCamelCase__				   =      reader.read_files([{"filename": filename}]      , in_memory=a__      )
       assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
       lowerCamelCase__				   =      dataset_kwargs["arrow_table"]
       assert table.shape == dataset.data.shape
       assert set(table.column_names      ) == set(dataset.data.column_names      )
       assert dict(table.to_pydict()      ) == dict(dataset.data.to_pydict()      )  # to_pydict returns OrderedDict







def   lowerCAmelCase(  ):







       '''simple docstring'''






       assert ReadInstruction("train"      , to=10      , unit="abs"      ).to_spec() == "train[:10]"
       assert ReadInstruction("train"      , from_=-80      , to=10      , unit="%"      ).to_spec() == "train[-80%:10%]"

       lowerCamelCase__				   =      "train+test"
       assert ReadInstruction.from_spec(a__      ).to_spec() == spec_train_test

       lowerCamelCase__				   =      "train[2:10]"
       assert ReadInstruction.from_spec(a__      ).to_spec() == spec_train_abs

       lowerCamelCase__				   =      "train[15%:-20%]"
       assert ReadInstruction.from_spec(a__      ).to_spec() == spec_train_pct

       lowerCamelCase__				   =      "train[:10%](closest)"
       assert ReadInstruction.from_spec(a__      ).to_spec() == "train[:10%]"

       lowerCamelCase__				   =      "train[:10%](pct1_dropremainder)"
       assert ReadInstruction.from_spec(a__      ).to_spec() == spec_train_pct_rounding

       lowerCamelCase__				   =      "train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)"
       assert ReadInstruction.from_spec(a__      ).to_spec() == spec_train_test_pct_rounding







def   lowerCAmelCase(  ):







       '''simple docstring'''






       lowerCamelCase__				   =      "dummy"
       lowerCamelCase__				   =      [SplitInfo(name="train"      , num_examples=100      )]
       lowerCamelCase__				   =      "train[:33%]"
       lowerCamelCase__				   =      "arrow"
       lowerCamelCase__				   =      "prefix"

       lowerCamelCase__				   =      make_file_instructions(a__      , a__      , a__      , a__      , a__      )
       assert isinstance(a__      , a__      )
       assert file_instructions.num_examples == 33
       assert file_instructions.file_instructions == [
           {"filename": os.path.join(a__      , f"""{name}-train.arrow"""      ), "skip": 0, "take": 33}
       ]

       lowerCamelCase__				   =      [SplitInfo(name="train"      , num_examples=100      , shard_lengths=[10] * 10      )]
       lowerCamelCase__				   =      make_file_instructions(a__      , a__      , a__      , a__      , a__      )
       assert isinstance(a__      , a__      )
       assert file_instructions.num_examples == 33
       assert file_instructions.file_instructions == [
           {"filename": os.path.join(a__      , f"""{name}-train-00000-of-00010.arrow"""      ), "skip": 0, "take": -1},
           {"filename": os.path.join(a__      , f"""{name}-train-00001-of-00010.arrow"""      ), "skip": 0, "take": -1},
           {"filename": os.path.join(a__      , f"""{name}-train-00002-of-00010.arrow"""      ), "skip": 0, "take": -1},
           {"filename": os.path.join(a__      , f"""{name}-train-00003-of-00010.arrow"""      ), "skip": 0, "take": 3},
       ]







@pytest.mark.parametrize("name, expected_exception"      , [(None, TypeError), ("", ValueError)]      )
def   lowerCAmelCase(  a__    :  List[str]      , a__    :  Tuple      ):







       '''simple docstring'''






       lowerCamelCase__				   =      [SplitInfo(name="train"      , num_examples=100      )]
       lowerCamelCase__				   =      "train"
       lowerCamelCase__				   =      "arrow"
       lowerCamelCase__				   =      "prefix_path"
       with pytest.raises(a__      ):
              lowerCamelCase__				   =      make_file_instructions(a__      , a__      , a__      , a__      , a__      )



'''simple docstring'''







import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class 		snake_case_       (						unittest.TestCase						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







   @property
   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      1
          lowerCamelCase__				   =      3
          lowerCamelCase__				   =      (32, 32)

          lowerCamelCase__				   =      floats_tensor((batch_size, num_channels) + sizes			,   rng=random.Random(0)).to(UpperCamelCase)
          return image







   @property
   def     __UpperCAmelCase      ( self):
          torch.manual_seed(0)
          lowerCamelCase__				   =      UNetaDConditionModel(
              block_out_channels=(32, 64)			,   layers_per_block=2			,   sample_size=32			,   in_channels=4			,   out_channels=4			,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")			,   up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")			,   cross_attention_dim=32			,   )
          return model







   @property
   def     __UpperCAmelCase      ( self):
          torch.manual_seed(0)
          lowerCamelCase__				   =      AutoencoderKL(
              block_out_channels=[32, 64]			,   in_channels=3			,   out_channels=3			,   down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]			,   up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]			,   latent_channels=4			,   )
          return model







   @property
   def     __UpperCAmelCase      ( self):
          torch.manual_seed(0)
          lowerCamelCase__				   =      CLIPTextConfig(
              bos_token_id=0			,   eos_token_id=2			,   hidden_size=32			,   intermediate_size=37			,   layer_norm_eps=1E-0_5			,   num_attention_heads=4			,   num_hidden_layers=5			,   pad_token_id=1			,   vocab_size=10_00			,   )
          return CLIPTextModel(UpperCamelCase)







   @property
   def     __UpperCAmelCase      ( self):
          def extract(*UpperCamelCase			,   **UpperCamelCase):







                 class 		snake_case_       :



                    """simple docstring"""





                    def __init__( self):
                           lowerCamelCase__				   =      torch.ones([0])







                    def     __UpperCAmelCase      ( self			,   UpperCamelCase):
                           self.pixel_values.to(UpperCamelCase)
                           return self






                 return Out()

          return extract







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__				   =      self.dummy_cond_unet
          lowerCamelCase__				   =      DDIMScheduler(
              beta_start=0.0_0_0_8_5			,   beta_end=0.0_1_2			,   beta_schedule="scaled_linear"			,   clip_sample=UpperCamelCase			,   set_alpha_to_one=UpperCamelCase			,   )

          lowerCamelCase__				   =      self.dummy_vae
          lowerCamelCase__				   =      self.dummy_text_encoder
          lowerCamelCase__				   =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

          # make sure here that pndm scheduler skips prk
          lowerCamelCase__				   =      StableDiffusionPipeline(
              unet=UpperCamelCase			,   scheduler=UpperCamelCase			,   vae=UpperCamelCase			,   text_encoder=UpperCamelCase			,   tokenizer=UpperCamelCase			,   safety_checker=UpperCamelCase			,   feature_extractor=self.dummy_extractor			,   )
          lowerCamelCase__				   =      sd_pipe.to(UpperCamelCase)
          sd_pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "A painting of a squirrel eating a burger"

          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe([prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np")
          lowerCamelCase__				   =      output.images

          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np"			,   return_dict=UpperCamelCase			,   )[0]

          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          lowerCamelCase__				   =      np.array([0.5_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__				   =      self.dummy_cond_unet
          lowerCamelCase__				   =      PNDMScheduler(skip_prk_steps=UpperCamelCase)
          lowerCamelCase__				   =      self.dummy_vae
          lowerCamelCase__				   =      self.dummy_text_encoder
          lowerCamelCase__				   =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

          # make sure here that pndm scheduler skips prk
          lowerCamelCase__				   =      StableDiffusionPipeline(
              unet=UpperCamelCase			,   scheduler=UpperCamelCase			,   vae=UpperCamelCase			,   text_encoder=UpperCamelCase			,   tokenizer=UpperCamelCase			,   safety_checker=UpperCamelCase			,   feature_extractor=self.dummy_extractor			,   )
          lowerCamelCase__				   =      sd_pipe.to(UpperCamelCase)
          sd_pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "A painting of a squirrel eating a burger"
          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe([prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np")

          lowerCamelCase__				   =      output.images

          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np"			,   return_dict=UpperCamelCase			,   )[0]

          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          lowerCamelCase__				   =      np.array([0.5_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained(
              "hf-internal-testing/tiny-stable-diffusion-lms-pipe"			,   safety_checker=UpperCamelCase)
          assert isinstance(UpperCamelCase			,   UpperCamelCase)
          assert isinstance(pipe.scheduler			,   UpperCamelCase)
          assert pipe.safety_checker is None

          lowerCamelCase__				   =      pipe("example prompt"			,   num_inference_steps=2).images[0]
          assert image is not None

          # check that there's no error when saving a pipeline with one of the models being None
          with tempfile.TemporaryDirectory() as tmpdirname:
                 pipe.save_pretrained(UpperCamelCase)
                 lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained(UpperCamelCase)

          # sanity check that the pipeline still works
          assert pipe.safety_checker is None
          lowerCamelCase__				   =      pipe("example prompt"			,   num_inference_steps=2).images[0]
          assert image is not None







   @unittest.skipIf(torch_device != "cuda"			,   "This test requires a GPU")
   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      self.dummy_cond_unet
          lowerCamelCase__				   =      PNDMScheduler(skip_prk_steps=UpperCamelCase)
          lowerCamelCase__				   =      self.dummy_vae
          lowerCamelCase__				   =      self.dummy_text_encoder
          lowerCamelCase__				   =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

          # put models in fp16
          lowerCamelCase__				   =      unet.half()
          lowerCamelCase__				   =      vae.half()
          lowerCamelCase__				   =      bert.half()

          # make sure here that pndm scheduler skips prk
          lowerCamelCase__				   =      StableDiffusionPipeline(
              unet=UpperCamelCase			,   scheduler=UpperCamelCase			,   vae=UpperCamelCase			,   text_encoder=UpperCamelCase			,   tokenizer=UpperCamelCase			,   safety_checker=UpperCamelCase			,   feature_extractor=self.dummy_extractor			,   )
          lowerCamelCase__				   =      sd_pipe.to(UpperCamelCase)
          sd_pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "A painting of a squirrel eating a burger"
          lowerCamelCase__				   =      sd_pipe([prompt]			,   num_inference_steps=2			,   output_type="np").images

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







@nightly
@require_torch_gpu
class 		snake_case_       (						unittest.TestCase						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "a photo of a cat"
          lowerCamelCase__				   =      {
              "editing_prompt": ["sunglasses"],
              "reverse_editing_direction": [False],
              "edit_warmup_steps": 10,
              "edit_guidance_scale": 6,
              "edit_threshold": 0.9_5,
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      3
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.3_4_6_7_3_1_1_3,
              0.3_8_4_9_2_7_3_3,
              0.3_7_5_9_7_3_5_2,
              0.3_4_0_8_6_3_3_5,
              0.3_5_6_5_0_7_4_8,
              0.3_5_5_7_9_2_0_5,
              0.3_3_8_4_7_6_3,
              0.3_4_3_4_0_2_3_6,
              0.3_5_7_3_2_7_1,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.4_1_8_8_7_8_2_6,
              0.3_7_7_2_8_7_6_6,
              0.3_0_1_3_8_2_7_2,
              0.4_1_4_1_6_3_3_5,
              0.4_1_6_6_4_9_8_5,
              0.3_6_2_8_3_3_9_2,
              0.3_6_1_9_1_2_4_6,
              0.4_3_3_6_4_4_6_5,
              0.4_3_0_0_1_7_3_2,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "an image of a crowded boulevard, realistic, 4k"
          lowerCamelCase__				   =      {
              "editing_prompt": "crowd, crowded, people",
              "reverse_editing_direction": True,
              "edit_warmup_steps": 10,
              "edit_guidance_scale": 8.3,
              "edit_threshold": 0.9,
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      9
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.4_3_4_9_7_9_9_8,
              0.9_1_8_1_4_0_6_5,
              0.7_5_4_0_7_3_9,
              0.5_5_5_8_0_2_0_5,
              0.8_4_6_7_2_6_5,
              0.5_3_8_9_6_9_1,
              0.6_2_5_7_4_5_0_6,
              0.5_8_8_9_7_7_6_3,
              0.5_0_9_2_6_7_5_7,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.3_0_8_9_7_1_9,
              0.3_0_5_0_0_1_4_4,
              0.2_9_0_1_6_0_4_2,
              0.3_0_6_3_0_9_6_4,
              0.3_2_5_6_8_7,
              0.2_9_4_1_9_2_2_5,
              0.2_9_0_8_0_9_1,
              0.2_8_7_2_3_5_9_8,
              0.2_7_6_9_6_2_9_4,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "a castle next to a river"
          lowerCamelCase__				   =      {
              "editing_prompt": ["boat on a river, boat", "monet, impression, sunrise"],
              "reverse_editing_direction": False,
              "edit_warmup_steps": [15, 18],
              "edit_guidance_scale": 6,
              "edit_threshold": [0.9, 0.8],
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      48
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.7_5_1_6_3_5_5_5,
              0.7_6_0_3_7_1_4_5,
              0.6_1_7_8_5,
              0.9_1_8_9_6_7_3,
              0.8_6_2_7_7_0_1,
              0.8_5_1_8_9_6_9_4,
              0.8_5_1_2_8_1_3,
              0.8_7_0_1_2_0_7_6,
              0.8_3_1_2_8_5_7,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.7_3_5_5_3_3_6_5,
              0.7_5_3_7_2_7_1,
              0.7_4_3_4_1_9_0_5,
              0.6_6_4_8_0_3_5_6,
              0.6_4_7_2_9_2_5,
              0.6_3_0_3_9_4_1_6,
              0.6_4_8_1_2_9_0_5,
              0.6_7_4_9_7_1_7,
              0.6_5_1_7_1_0_2,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"			,   torch_dtype=torch.floataa)
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "a photo of a cat"
          lowerCamelCase__				   =      {
              "editing_prompt": ["sunglasses"],
              "reverse_editing_direction": [False],
              "edit_warmup_steps": 10,
              "edit_guidance_scale": 6,
              "edit_threshold": 0.9_5,
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      3
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.3_4_8_8_7_6_9_5,
              0.3_8_7_6_9_5_3,
              0.3_7_5,
              0.3_4_4_2_3_8_2_8,
              0.3_5_8_1_5_4_3,
              0.3_5_7_1_7_7_7_3,
              0.3_3_8_3_7_8_9,
              0.3_4_5_7_0_3_1_2,
              0.3_5_9_3_7_5,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.4_2_2_8_5_1_5_6,
              0.3_6_9_1_4_0_6_2,
              0.2_9_0_7_7_1_4_8,
              0.4_2_0_4_1_0_1_6,
              0.4_1_9_1_8_9_4_5,
              0.3_5_4_9_8_0_4_7,
              0.3_6_1_8_1_6_4,
              0.4_4_2_3_8_2_8,
              0.4_3_1_1_5_2_3_4,
          ]

          assert image.shape == (1, 5_12, 5_12, 3)

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

