
import unittest

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

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class   UpperCAmelCase		(						unittest.TestCase ):



   @property
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	Union[str, Any]:


          '''simple docstring'''


          torch.manual_seed(0 )
          snake_case       :   Dict							=      UNetaDModel(
              block_out_channels=(32, 64)    ,						layers_per_block=2    ,						sample_size=32    ,						in_channels=3    ,						out_channels=3    ,						down_block_types=("DownBlock2D", "AttnDownBlock2D")    ,						up_block_types=("AttnUpBlock2D", "UpBlock2D")    ,						)
          return model



   @property
   def 				_SCREAMING_SNAKE_CASE   (self		:					Union[str, Any] )		->	int:


          '''simple docstring'''


          torch.manual_seed(0 )
          snake_case       :   Optional[Any]							=      VQModel(
              block_out_channels=[32, 64]    ,						in_channels=3    ,						out_channels=3    ,						down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]    ,						up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]    ,						latent_channels=3    ,						)
          return model



   @property
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	List[Any]:


          '''simple docstring'''


          torch.manual_seed(0 )
          snake_case       :   int							=      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=10_00    ,						)
          return CLIPTextModel(snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Dict:


          '''simple docstring'''


          snake_case       :   List[Any]							=      self.dummy_uncond_unet
          snake_case       :   List[Any]							=      DDIMScheduler()
          snake_case       :   Optional[Any]							=      self.dummy_vq_model

          snake_case       :   str							=      LDMPipeline(unet=snake_case__    ,						vqvae=snake_case__    ,						scheduler=snake_case__ )
          ldm.to(snake_case__ )
          ldm.set_progress_bar_config(disable=snake_case__ )

          snake_case       :   Tuple							=      torch.manual_seed(0 )
          snake_case       :   Any							=      ldm(generator=snake_case__    ,						num_inference_steps=2    ,						output_type="numpy" ).images

          snake_case       :   List[Any]							=      torch.manual_seed(0 )
          snake_case       :   Tuple							=      ldm(generator=snake_case__    ,						num_inference_steps=2    ,						output_type="numpy"    ,						return_dict=snake_case__ )[0]

          snake_case       :   Tuple							=      image[0, -3:, -3:, -1]
          snake_case       :   Optional[int]							=      image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          snake_case       :   int							=      np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172] )
          snake_case       :   Any							=      1e-2 if torch_device != "mps" else 3e-2

          assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance






@slow
@require_torch
class   UpperCAmelCase		(						unittest.TestCase ):



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	str:


          '''simple docstring'''


          snake_case       :   int							=      LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256" )
          ldm.to(snake_case__ )
          ldm.set_progress_bar_config(disable=snake_case__ )

          snake_case       :   List[str]							=      torch.manual_seed(0 )
          snake_case       :   Any							=      ldm(generator=snake_case__    ,						num_inference_steps=5    ,						output_type="numpy" ).images

          snake_case       :   Any							=      image[0, -3:, -3:, -1]

          assert image.shape == (1, 2_56, 2_56, 3)
          snake_case       :   List[str]							=      np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447] )
          snake_case       :   Optional[int]							=      1e-2 if torch_device != "mps" else 3e-2

          assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance












from __future__ import annotations




def 		lowerCAmelCase_    (  __UpperCAmelCase:			list[int]		,   __UpperCAmelCase:			int      )      ->	list[int]:
    UpperCamelCase__							:				Optional[int]          =      0
    UpperCamelCase__							:				Tuple          =      len(__UpperCAmelCase      ) - 1

    while i < j:
        if nums[i] + nums[j] == target:
            return [i, j]
        elif nums[i] + nums[j] < target:
            UpperCamelCase__							:				Tuple          =      i + 1
        else:
            UpperCamelCase__							:				str          =      j - 1

    return []


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  print(F'''{two_pointer([2, 7, 11, 15], 9) = }''')

