

class  UpperCAmelCase__	:






  """simple docstring"""


  def __init__(							self		:	int			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Union[str, Any]      )	->							str:
       SCREAMING_SNAKE_CASE__					=					None
       SCREAMING_SNAKE_CASE__					=					None
       SCREAMING_SNAKE_CASE__					=					graph

       self._normalize_graph(__lowerCamelCase			,     __lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					len(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					None






  def    lowercase_	(							self		:	Any			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Union[str, Any]      )	->							str:
       if sources is int:
            SCREAMING_SNAKE_CASE__					=					[sources]
       if sinks is int:
            SCREAMING_SNAKE_CASE__					=					[sinks]

       if len(__lowerCamelCase      ) == 0 or len(__lowerCamelCase      ) == 0:
            return

       SCREAMING_SNAKE_CASE__					=					sources[0]
       SCREAMING_SNAKE_CASE__					=					sinks[0]

       # make fake vertex if there are more
       # than one source or sink
       if len(__lowerCamelCase      ) > 1 or len(__lowerCamelCase      ) > 1:
            SCREAMING_SNAKE_CASE__					=					0
            for i in sources:
                 max_input_flow += sum(self.graph[i]      )

            SCREAMING_SNAKE_CASE__					=					len(self.graph      ) + 1
            for room in self.graph:
                 room.insert(0			,     0      )
            self.graph.insert(0			,     [0] * size      )
            for i in sources:
                 SCREAMING_SNAKE_CASE__					=					max_input_flow
            SCREAMING_SNAKE_CASE__					=					0

            SCREAMING_SNAKE_CASE__					=					len(self.graph      ) + 1
            for room in self.graph:
                 room.append(0      )
            self.graph.append([0] * size      )
            for i in sinks:
                 SCREAMING_SNAKE_CASE__					=					max_input_flow
            SCREAMING_SNAKE_CASE__					=					size - 1






  def    lowercase_	(							self		:	Dict      )	->							List[Any]:
       if self.maximum_flow_algorithm is None:
            raise Exception('''You need to set maximum flow algorithm before.'''      )
       if self.source_index is None or self.sink_index is None:
            return 0

       self.maximum_flow_algorithm.execute()
       return self.maximum_flow_algorithm.getMaximumFlow()







  def    lowercase_	(							self		:	Union[str, Any]			,     __lowerCamelCase		:	List[Any]      )	->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__					=					algorithm(self      )






class  UpperCAmelCase__	:






  """simple docstring"""


  def __init__(							self		:	Optional[int]			,     __lowerCamelCase		:	int      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					flow_network
       SCREAMING_SNAKE_CASE__					=					flow_network.verticesCount
       SCREAMING_SNAKE_CASE__					=					flow_network.sourceIndex
       SCREAMING_SNAKE_CASE__					=					flow_network.sinkIndex
       # it's just a reference, so you shouldn't change
       # it in your algorithms, use deep copy before doing that
       SCREAMING_SNAKE_CASE__					=					flow_network.graph
       SCREAMING_SNAKE_CASE__					=					False






  def    lowercase_	(							self		:	Optional[int]      )	->							Tuple:
       if not self.executed:
            self._algorithm()
            SCREAMING_SNAKE_CASE__					=					True







  def    lowercase_	(							self		:	Any      )	->							List[str]:
       pass






class  UpperCAmelCase__	( _A ):






  """simple docstring"""


  def __init__(							self		:	int			,     __lowerCamelCase		:	Tuple      )	->							Dict:
       super().__init__(__lowerCamelCase      )
       # use this to save your result
       SCREAMING_SNAKE_CASE__					=					-1







  def    lowercase_	(							self		:	Optional[Any]      )	->							int:
       if not self.executed:
            raise Exception('''You should execute algorithm before using its result!'''      )

       return self.maximum_flow






class  UpperCAmelCase__	( _A ):






  """simple docstring"""


  def __init__(							self		:	Dict			,     __lowerCamelCase		:	Any      )	->							Tuple:
       super().__init__(__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					[[0] * self.verticies_count for i in range(self.verticies_count      )]

       SCREAMING_SNAKE_CASE__					=					[0] * self.verticies_count
       SCREAMING_SNAKE_CASE__					=					[0] * self.verticies_count






  def    lowercase_	(							self		:	str      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.verticies_count

       # push some substance to graph
       for nextvertex_index, bandwidth in enumerate(self.graph[self.source_index]      ):
            self.preflow[self.source_index][nextvertex_index] += bandwidth
            self.preflow[nextvertex_index][self.source_index] -= bandwidth
            self.excesses[nextvertex_index] += bandwidth

       # Relabel-to-front selection rule
       SCREAMING_SNAKE_CASE__					=					[
           i
           for i in range(self.verticies_count      )
           if i != self.source_index and i != self.sink_index
       ]

       # move through list
       SCREAMING_SNAKE_CASE__					=					0
       while i < len(__lowerCamelCase      ):
            SCREAMING_SNAKE_CASE__					=					vertices_list[i]
            SCREAMING_SNAKE_CASE__					=					self.heights[vertex_index]
            self.process_vertex(__lowerCamelCase      )
            if self.heights[vertex_index] > previous_height:
                 # if it was relabeled, swap elements
                 # and start from 0 index
                 vertices_list.insert(0			,     vertices_list.pop(__lowerCamelCase      )      )
                 SCREAMING_SNAKE_CASE__					=					0
            else:
                 i += 1

       SCREAMING_SNAKE_CASE__					=					sum(self.preflow[self.source_index]      )






  def    lowercase_	(							self		:	str			,     __lowerCamelCase		:	str      )	->							List[str]:
       while self.excesses[vertex_index] > 0:
            for neighbour_index in range(self.verticies_count      ):
                 # if it's neighbour and current vertex is higher
                 if (
                     self.graph[vertex_index][neighbour_index]
                     - self.preflow[vertex_index][neighbour_index]
                     > 0
                     and self.heights[vertex_index] > self.heights[neighbour_index]
                 ):
                      self.push(__lowerCamelCase			,     __lowerCamelCase      )

            self.relabel(__lowerCamelCase      )






  def    lowercase_	(							self		:	Dict			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Tuple      )	->							int:
       SCREAMING_SNAKE_CASE__					=					min(
           self.excesses[from_index]			,     self.graph[from_index][to_index] - self.preflow[from_index][to_index]			,     )
       self.preflow[from_index][to_index] += preflow_delta
       self.preflow[to_index][from_index] -= preflow_delta
       self.excesses[from_index] -= preflow_delta
       self.excesses[to_index] += preflow_delta







  def    lowercase_	(							self		:	Optional[Any]			,     __lowerCamelCase		:	Dict      )	->							int:
       SCREAMING_SNAKE_CASE__					=					None
       for to_index in range(self.verticies_count      ):
            if (
                self.graph[vertex_index][to_index]
                - self.preflow[vertex_index][to_index]
                > 0
            ) and (min_height is None or self.heights[to_index] < min_height):
                 SCREAMING_SNAKE_CASE__					=					self.heights[to_index]

       if min_height is not None:
            SCREAMING_SNAKE_CASE__					=					min_height + 1


if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE  :						Dict         =    [0]
       _SCREAMING_SNAKE_CASE  :						Optional[int]         =    [3]
       # graph = [
       #     [0, 0, 4, 6, 0, 0],
       #     [0, 0, 5, 2, 0, 0],
       #     [0, 0, 0, 0, 4, 4],
       #     [0, 0, 0, 0, 6, 6],
       #     [0, 0, 0, 0, 0, 0],
       #     [0, 0, 0, 0, 0, 0],
       # ]
       _SCREAMING_SNAKE_CASE  :						Tuple         =    [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]]

       # prepare our network
       _SCREAMING_SNAKE_CASE  :						Union[str, Any]         =    FlowNetwork(graph, entrances, exits)
       # set algorithm
       flow_network.set_maximum_flow_algorithm(PushRelabelExecutor)
       # and calculate
       _SCREAMING_SNAKE_CASE  :						List[str]         =    flow_network.find_maximum_flow()

       print(F"maximum flow is {maximum_flow}")






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






@skip_mps
class  UpperCAmelCase__	( A__		,  A__		,  unittest.TestCase ):






  """simple docstring"""


  a     =      StableDiffusionPanoramaPipeline
  a     =      TEXT_TO_IMAGE_PARAMS
  a     =      TEXT_TO_IMAGE_BATCH_PARAMS
  a     =      TEXT_TO_IMAGE_IMAGE_PARAMS
  a     =      TEXT_TO_IMAGE_IMAGE_PARAMS






  def    lowercase_	(							self		:	Union[str, Any]      )	->							List[str]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					UNetaDConditionModel(
           block_out_channels=(32, 64)			,     layers_per_block=1			,     sample_size=32			,     in_channels=4			,     out_channels=4			,     down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')			,     up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')			,     cross_attention_dim=32			,     )
       SCREAMING_SNAKE_CASE__					=					DDIMScheduler()
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					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			,     )
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					CLIPTextConfig(
           bos_token_id=0			,     eos_token_id=2			,     hidden_size=32			,     intermediate_size=37			,     layer_norm_eps=1e-05			,     num_attention_heads=4			,     num_hidden_layers=5			,     pad_token_id=1			,     vocab_size=1000			,     )
       SCREAMING_SNAKE_CASE__					=					CLIPTextModel(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

       SCREAMING_SNAKE_CASE__					=					{
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components






  def    lowercase_	(							self		:	Union[str, Any]			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	List[str]=0      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					torch.manual_seed(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					{
           '''prompt''': '''a photo of the dolomites''',
           '''generator''': generator,
           # Setting height and width to None to prevent OOMs on CPU.
           '''height''': None,
           '''width''': None,
           '''num_inference_steps''': 1,
           '''guidance_scale''': 6.0,
           '''output_type''': '''numpy''',
       }
       return inputs






  def    lowercase_	(							self		:	Optional[int]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe.to(__lowerCamelCase      )
       sd_pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_inputs(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe(**__lowerCamelCase      ).images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]
       assert image.shape == (1, 64, 64, 3)

       SCREAMING_SNAKE_CASE__					=					np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]      )

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






  def    lowercase_	(							self		:	Any      )	->							Optional[Any]:
       super().test_inference_batch_consistent(batch_sizes=[1, 2]      )






  def    lowercase_	(							self		:	List[Any]      )	->							List[Any]:
       super().test_inference_batch_single_identical(batch_size=2			,     expected_max_diff=3.25e-3      )






  def    lowercase_	(							self		:	Union[str, Any]      )	->							str:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe.to(__lowerCamelCase      )
       sd_pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_inputs(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					'''french fries'''
       SCREAMING_SNAKE_CASE__					=					sd_pipe(**__lowerCamelCase			,     negative_prompt=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					output.images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]

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

       SCREAMING_SNAKE_CASE__					=					np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]      )

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






  def    lowercase_	(							self		:	Tuple      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe.to(__lowerCamelCase      )
       sd_pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_inputs(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe(**__lowerCamelCase			,     view_batch_size=2      )
       SCREAMING_SNAKE_CASE__					=					output.images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]

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

       SCREAMING_SNAKE_CASE__					=					np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]      )

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






  def    lowercase_	(							self		:	Optional[Any]      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()
       SCREAMING_SNAKE_CASE__					=					EulerAncestralDiscreteScheduler(
           beta_start=0.00085			,     beta_end=0.012			,     beta_schedule='''scaled_linear'''      )
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe.to(__lowerCamelCase      )
       sd_pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_inputs(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe(**__lowerCamelCase      ).images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]

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

       SCREAMING_SNAKE_CASE__					=					np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]      )

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







  def    lowercase_	(							self		:	Optional[int]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()
       SCREAMING_SNAKE_CASE__					=					PNDMScheduler(
           beta_start=0.00085			,     beta_end=0.012			,     beta_schedule='''scaled_linear'''			,     skip_prk_steps=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe.to(__lowerCamelCase      )
       sd_pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_inputs(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					sd_pipe(**__lowerCamelCase      ).images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]

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

       SCREAMING_SNAKE_CASE__					=					np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]      )

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






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






  """simple docstring"""


  def    lowercase_	(							self		:	Tuple      )	->							str:
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






  def    lowercase_	(							self		:	Any			,     __lowerCamelCase		:	Dict=0      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					torch.manual_seed(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					{
           '''prompt''': '''a photo of the dolomites''',
           '''generator''': generator,
           '''num_inference_steps''': 3,
           '''guidance_scale''': 7.5,
           '''output_type''': '''numpy''',
       }
       return inputs






  def    lowercase_	(							self		:	Union[str, Any]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					'''stabilityai/stable-diffusion-2-base'''
       SCREAMING_SNAKE_CASE__					=					DDIMScheduler.from_pretrained(__lowerCamelCase			,     subfolder='''scheduler'''      )
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline.from_pretrained(__lowerCamelCase			,     scheduler=__lowerCamelCase			,     safety_checker=__lowerCamelCase      )
       pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )
       pipe.enable_attention_slicing()

       SCREAMING_SNAKE_CASE__					=					self.get_inputs()
       SCREAMING_SNAKE_CASE__					=					pipe(**__lowerCamelCase      ).images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 512, 2048, 3)

       SCREAMING_SNAKE_CASE__					=					np.array(
           [
               0.36968392,
               0.27025372,
               0.32446766,
               0.28379387,
               0.36363274,
               0.30733347,
               0.27100027,
               0.27054125,
               0.25536096,
           ]      )

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






  def    lowercase_	(							self		:	Optional[Any]      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline.from_pretrained(
           '''stabilityai/stable-diffusion-2-base'''			,     safety_checker=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
       pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )
       pipe.enable_attention_slicing()

       SCREAMING_SNAKE_CASE__					=					self.get_inputs()
       SCREAMING_SNAKE_CASE__					=					pipe(**__lowerCamelCase      ).images
       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 512, 2048, 3)

       SCREAMING_SNAKE_CASE__					=					np.array(
           [
               [
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
                   0.0,
               ]
           ]      )

       assert np.abs(expected_slice - image_slice      ).max() < 1e-3






  def    lowercase_	(							self		:	List[str]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					0

       def callback_fn(__lowerCamelCase		:	int			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	torch.FloatTensor      ) -> None:
            SCREAMING_SNAKE_CASE__					=					True
            nonlocal number_of_steps
            number_of_steps += 1
            if step == 1:
                 SCREAMING_SNAKE_CASE__					=					latents.detach().cpu().numpy()
                 assert latents.shape == (1, 4, 64, 256)
                 SCREAMING_SNAKE_CASE__					=					latents[0, -3:, -3:, -1]

                 SCREAMING_SNAKE_CASE__					=					np.array(
                     [
                         0.18681869,
                         0.33907816,
                         0.5361276,
                         0.14432865,
                         -0.02856611,
                         -0.73941123,
                         0.23397987,
                         0.47322682,
                         -0.37823164,
                     ]      )
                 assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5e-2
            elif step == 2:
                 SCREAMING_SNAKE_CASE__					=					latents.detach().cpu().numpy()
                 assert latents.shape == (1, 4, 64, 256)
                 SCREAMING_SNAKE_CASE__					=					latents[0, -3:, -3:, -1]

                 SCREAMING_SNAKE_CASE__					=					np.array(
                     [
                         0.18539645,
                         0.33987248,
                         0.5378559,
                         0.14437142,
                         -0.02455261,
                         -0.7338317,
                         0.23990755,
                         0.47356272,
                         -0.3786505,
                     ]      )

                 assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5e-2

       SCREAMING_SNAKE_CASE__					=					False

       SCREAMING_SNAKE_CASE__					=					'''stabilityai/stable-diffusion-2-base'''
       SCREAMING_SNAKE_CASE__					=					DDIMScheduler.from_pretrained(__lowerCamelCase			,     subfolder='''scheduler'''      )
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline.from_pretrained(__lowerCamelCase			,     scheduler=__lowerCamelCase			,     safety_checker=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )
       pipe.enable_attention_slicing()

       SCREAMING_SNAKE_CASE__					=					self.get_inputs()
       pipe(**__lowerCamelCase			,     callback=__lowerCamelCase			,     callback_steps=1      )
       assert callback_fn.has_been_called
       assert number_of_steps == 3







  def    lowercase_	(							self		:	Tuple      )	->							Tuple:
       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       SCREAMING_SNAKE_CASE__					=					'''stabilityai/stable-diffusion-2-base'''
       SCREAMING_SNAKE_CASE__					=					DDIMScheduler.from_pretrained(__lowerCamelCase			,     subfolder='''scheduler'''      )
       SCREAMING_SNAKE_CASE__					=					StableDiffusionPanoramaPipeline.from_pretrained(__lowerCamelCase			,     scheduler=__lowerCamelCase			,     safety_checker=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					pipe.to(__lowerCamelCase      )
       pipe.set_progress_bar_config(disable=__lowerCamelCase      )
       pipe.enable_attention_slicing(1      )
       pipe.enable_sequential_cpu_offload()

       SCREAMING_SNAKE_CASE__					=					self.get_inputs()
       SCREAMING_SNAKE_CASE__					=					pipe(**__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					torch.cuda.max_memory_allocated()
       # make sure that less than 5.2 GB is allocated
       assert mem_bytes < 5.5 * 10**9


