



"""simple docstring"""





import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class    _lowerCAmelCase    (				__a  ,				__a  ,				unittest.TestCase		):





  """simple docstring"""






  _lowerCamelCase			  =       StableDiffusionXLImgaImgPipeline
  _lowerCamelCase			  =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
  _lowerCamelCase			  =       PipelineTesterMixin.required_optional_params - {'''latents'''}
  _lowerCamelCase			  =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  _lowerCamelCase			  =       IMAGE_TO_IMAGE_IMAGE_PARAMS
  _lowerCamelCase			  =       IMAGE_TO_IMAGE_IMAGE_PARAMS





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







        '''simple docstring'''

        torch.manual_seed(0   )
        snake_case_   : Any						=			UNetaDConditionModel(
            block_out_channels=(3_2, 6_4)							,    layers_per_block=2							,    sample_size=3_2							,    in_channels=4							,    out_channels=4							,    down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")							,    up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")							,    attention_head_dim=(2, 4)							,    use_linear_projection=a_							,    addition_embed_type="""text_time"""							,    addition_time_embed_dim=8							,    transformer_layers_per_block=(1, 2)							,    projection_class_embeddings_input_dim=8_0							,    cross_attention_dim=6_4							,    )
        snake_case_   : List[str]						=			EulerDiscreteScheduler(
            beta_start=0.0_0085							,    beta_end=0.012							,    steps_offset=1							,    beta_schedule="""scaled_linear"""							,    timestep_spacing="""leading"""							,    )
        torch.manual_seed(0   )
        snake_case_   : Optional[Any]						=			AutoencoderKL(
            block_out_channels=[3_2, 6_4]							,    in_channels=3							,    out_channels=3							,    down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]							,    up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]							,    latent_channels=4							,    sample_size=1_2_8							,    )
        torch.manual_seed(0   )
        snake_case_   : Union[str, Any]						=			CLIPTextConfig(
            bos_token_id=0							,    eos_token_id=2							,    hidden_size=3_2							,    intermediate_size=3_7							,    layer_norm_eps=1E-05							,    num_attention_heads=4							,    num_hidden_layers=5							,    pad_token_id=1							,    vocab_size=1_0_0_0							,    hidden_act="""gelu"""							,    projection_dim=3_2							,    )
        snake_case_   : Dict						=			CLIPTextModel(a_   )
        snake_case_   : Dict						=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							,    local_files_only=a_   )

        snake_case_   : Tuple						=			CLIPTextModelWithProjection(a_   )
        snake_case_   : int						=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							,    local_files_only=a_   )

        snake_case_   : Union[str, Any]						=			{
            """unet""": unet,
            """scheduler""": scheduler,
            """vae""": vae,
            """text_encoder""": text_encoder,
            """tokenizer""": tokenizer,
            """text_encoder_2""": text_encoder_a,
            """tokenizer_2""": tokenizer_a,
            # "safety_checker": None,
            # "feature_extractor": None,
        }
        return components





  def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase=0   ) ->						Union[str, Any]:







        '''simple docstring'''

        snake_case_   : int						=			floats_tensor((1, 3, 3_2, 3_2)							,    rng=random.Random(a_   )   ).to(a_   )
        snake_case_   : Optional[int]						=			image / 2 + 0.5
        if str(a_   ).startswith("""mps"""   ):
              snake_case_   : Optional[int]						=			torch.manual_seed(a_   )
        else:
              snake_case_   : str						=			torch.Generator(device=a_   ).manual_seed(a_   )
        snake_case_   : str						=			{
            """prompt""": """A painting of a squirrel eating a burger""",
            """image""": image,
            """generator""": generator,
            """num_inference_steps""": 2,
            """guidance_scale""": 5.0,
            """output_type""": """numpy""",
            """strength""": 0.75,
        }
        return inputs





  def    UpperCAmelCase__							(					self   ) ->						Tuple:







        '''simple docstring'''

        snake_case_   : Tuple						=			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
        snake_case_   : Tuple						=			self.get_dummy_components()
        snake_case_   : List[Any]						=			StableDiffusionXLImgaImgPipeline(**a_   )
        snake_case_   : Optional[Any]						=			sd_pipe.to(a_   )
        sd_pipe.set_progress_bar_config(disable=a_   )

        snake_case_   : str						=			self.get_dummy_inputs(a_   )
        snake_case_   : List[Any]						=			sd_pipe(**a_   ).images
        snake_case_   : int						=			image[0, -3:, -3:, -1]

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

        snake_case_   : List[Any]						=			np.array([0.4656, 0.4840, 0.4439, 0.6698, 0.5574, 0.4524, 0.5799, 0.5943, 0.5165]   )

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





  def    UpperCAmelCase__							(					self   ) ->						Optional[int]:







        '''simple docstring'''

        super().test_attention_slicing_forward_pass(expected_max_diff=3E-3   )





  def    UpperCAmelCase__							(					self   ) ->						List[str]:







        '''simple docstring'''

        super().test_inference_batch_single_identical(expected_max_diff=3E-3   )





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







        '''simple docstring'''

        pass





  def    UpperCAmelCase__							(					self   ) ->						int:







        '''simple docstring'''

        snake_case_   : Optional[Any]						=			self.get_dummy_components()
        snake_case_   : Tuple						=			StableDiffusionXLImgaImgPipeline(**a_   )
        snake_case_   : Union[str, Any]						=			sd_pipe.to(a_   )
        snake_case_   : int						=			sd_pipe.to(a_   )
        sd_pipe.set_progress_bar_config(disable=a_   )

        # forward without prompt embeds
        snake_case_   : str						=			self.get_dummy_inputs(a_   )
        snake_case_   : Any						=			3 * ["""this is a negative prompt"""]
        snake_case_   : Optional[Any]						=			negative_prompt
        snake_case_   : Optional[Any]						=			3 * [inputs["""prompt"""]]

        snake_case_   : Any						=			sd_pipe(**a_   )
        snake_case_   : List[str]						=			output.images[0, -3:, -3:, -1]

        # forward with prompt embeds
        snake_case_   : Optional[int]						=			self.get_dummy_inputs(a_   )
        snake_case_   : Any						=			3 * ["""this is a negative prompt"""]
        snake_case_   : List[str]						=			3 * [inputs.pop("""prompt"""   )]

        (
            snake_case_      
        )   : str						=			sd_pipe.encode_prompt(a_							,    negative_prompt=a_   )

        snake_case_   : Any						=			sd_pipe(
            **a_							,    prompt_embeds=a_							,    negative_prompt_embeds=a_							,    pooled_prompt_embeds=a_							,    negative_pooled_prompt_embeds=a_							,    )
        snake_case_   : Optional[Any]						=			output.images[0, -3:, -3:, -1]

        # make sure that it's equal
        assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()   ).max() < 1E-4




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





  """simple docstring"""






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







        '''simple docstring'''

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





  def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase="cpu"							,    _lowercase=torch.floataa							,    _lowercase=0   ) ->						Optional[int]:







        '''simple docstring'''

        snake_case_   : str						=			torch.Generator(device=a_   ).manual_seed(a_   )
        snake_case_   : Any						=			np.random.RandomState(a_   ).standard_normal((1, 4, 6_4, 6_4)   )
        snake_case_   : str						=			torch.from_numpy(a_   ).to(device=a_							,    dtype=a_   )
        snake_case_   : int						=			{
            """prompt""": """a photograph of an astronaut riding a horse""",
            """latents""": latents,
            """generator""": generator,
            """num_inference_steps""": 3,
            """guidance_scale""": 7.5,
            """output_type""": """numpy""",
        }
        return inputs





  def    UpperCAmelCase__							(					self   ) ->						str:







        '''simple docstring'''

        snake_case_   : str						=			DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""   )
        pipe.to(a_   )
        pipe.set_progress_bar_config(disable=a_   )

        snake_case_   : int						=			self.get_inputs(a_   )
        snake_case_   : Dict						=			pipe(**a_   ).images
        snake_case_   : Optional[int]						=			image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        snake_case_   : Optional[int]						=			np.array([0.4_9493, 0.4_7896, 0.4_0798, 0.5_4214, 0.5_3212, 0.4_8202, 0.4_7656, 0.4_6329, 0.4_8506]   )
        assert np.abs(image_slice - expected_slice   ).max() < 7E-3






"""simple docstring"""





def 	__lowerCAmelCase						(		__UpperCamelCase      :			Union[str, Any]    ):


						'''simple docstring'''






						snake_case_   : int						=			[0] * len(__UpperCamelCase    )
						snake_case_   : List[str]						=			[]
						snake_case_   : Any						=			[1] * len(__UpperCamelCase    )

						for values in graph.values():
												for i in values:
																		indegree[i] += 1

						for i in range(len(__UpperCamelCase    )    ):
												if indegree[i] == 0:
																		queue.append(__UpperCamelCase    )

						while queue:
												snake_case_   : Optional[int]						=			queue.pop(0    )
												for x in graph[vertex]:
																		indegree[x] -= 1

																		if long_dist[vertex] + 1 > long_dist[x]:
																								snake_case_   : Union[str, Any]						=			long_dist[vertex] + 1

																		if indegree[x] == 0:
																								queue.append(__UpperCamelCase    )

						print(max(__UpperCamelCase    )    )


# Adjacency list of Graph
__lowerCAmelCase       :					str      					=					{0: [2, 3, 4], 1: [2, 7], 2: [5], 3: [5, 7], 4: [7], 5: [6], 6: [7], 7: []}






longest_distance(graph)

