
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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()





class 							UpperCamelCase__						(     a__    ,  a__    ,  unittest.TestCase     ):






       """simple docstring"""


       UpperCAmelCase_							    =StableDiffusionSAGPipeline
       UpperCAmelCase_							    =TEXT_TO_IMAGE_PARAMS
       UpperCAmelCase_							    =TEXT_TO_IMAGE_BATCH_PARAMS
       UpperCAmelCase_							    =TEXT_TO_IMAGE_IMAGE_PARAMS
       UpperCAmelCase_							    =TEXT_TO_IMAGE_IMAGE_PARAMS
       UpperCAmelCase_							    =False



       def   _UpperCamelCase     (				self     )							->							Tuple:
          torch.manual_seed(0     )
          SCREAMING_SNAKE_CASE_     =	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      ,			)
          SCREAMING_SNAKE_CASE_     =	DDIMScheduler(
              beta_start=0.0_0085      ,			beta_end=0.012      ,			beta_schedule='''scaled_linear'''      ,			clip_sample=SCREAMING_SNAKE_CASE_      ,			set_alpha_to_one=SCREAMING_SNAKE_CASE_      ,			)
          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(SCREAMING_SNAKE_CASE_     )
          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   _UpperCamelCase     (				self      ,			_A      ,			_A=0     )							->							List[Any]:
          if str(SCREAMING_SNAKE_CASE_     ).startswith('''mps'''     ):
             SCREAMING_SNAKE_CASE_     =	torch.manual_seed(SCREAMING_SNAKE_CASE_     )
          else:
             SCREAMING_SNAKE_CASE_     =	torch.Generator(device=SCREAMING_SNAKE_CASE_     ).manual_seed(SCREAMING_SNAKE_CASE_     )
          SCREAMING_SNAKE_CASE_     =	{
              'prompt': '.',
              'generator': generator,
              'num_inference_steps': 2,
              'guidance_scale': 1.0,
              'sag_scale': 1.0,
              'output_type': 'numpy',
          }
          return inputs




       def   _UpperCamelCase     (				self     )							->							int:
          super().test_inference_batch_single_identical(expected_max_diff=3E-3     )







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






       """simple docstring"""


       def   _UpperCamelCase     (				self     )							->							Optional[int]:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



       def   _UpperCamelCase     (				self     )							->							str:
          SCREAMING_SNAKE_CASE_     =	StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''     )
          SCREAMING_SNAKE_CASE_     =	sag_pipe.to(SCREAMING_SNAKE_CASE_     )
          sag_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

          SCREAMING_SNAKE_CASE_     =	'.'
          SCREAMING_SNAKE_CASE_     =	torch.manual_seed(0     )
          SCREAMING_SNAKE_CASE_     =	sag_pipe(
              [prompt]      ,			generator=SCREAMING_SNAKE_CASE_      ,			guidance_scale=7.5      ,			sag_scale=1.0      ,			num_inference_steps=20      ,			output_type='''np'''     )

          SCREAMING_SNAKE_CASE_     =	output.images

          SCREAMING_SNAKE_CASE_     =	image[0, -3:, -3:, -1]

          assert image.shape == (1, 512, 512, 3)
          SCREAMING_SNAKE_CASE_     =	np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]     )

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



       def   _UpperCamelCase     (				self     )							->							Tuple:
          SCREAMING_SNAKE_CASE_     =	StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''     )
          SCREAMING_SNAKE_CASE_     =	sag_pipe.to(SCREAMING_SNAKE_CASE_     )
          sag_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

          SCREAMING_SNAKE_CASE_     =	'.'
          SCREAMING_SNAKE_CASE_     =	torch.manual_seed(0     )
          SCREAMING_SNAKE_CASE_     =	sag_pipe(
              [prompt]      ,			generator=SCREAMING_SNAKE_CASE_      ,			guidance_scale=7.5      ,			sag_scale=1.0      ,			num_inference_steps=20      ,			output_type='''np'''     )

          SCREAMING_SNAKE_CASE_     =	output.images

          SCREAMING_SNAKE_CASE_     =	image[0, -3:, -3:, -1]

          assert image.shape == (1, 512, 512, 3)
          SCREAMING_SNAKE_CASE_     =	np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]     )

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




       def   _UpperCamelCase     (				self     )							->							Optional[int]:
          SCREAMING_SNAKE_CASE_     =	StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''     )
          SCREAMING_SNAKE_CASE_     =	sag_pipe.to(SCREAMING_SNAKE_CASE_     )
          sag_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_     )

          SCREAMING_SNAKE_CASE_     =	'.'
          SCREAMING_SNAKE_CASE_     =	torch.manual_seed(0     )
          SCREAMING_SNAKE_CASE_     =	sag_pipe(
              [prompt]      ,			width=768      ,			height=512      ,			generator=SCREAMING_SNAKE_CASE_      ,			guidance_scale=7.5      ,			sag_scale=1.0      ,			num_inference_steps=20      ,			output_type='''np'''      ,			)

          SCREAMING_SNAKE_CASE_     =	output.images

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







import functools
from typing import Any
def 		UpperCamelCase	(   snake_case__       :    str       ,     snake_case__       :    list[str]	)	->     bool:

   # Validation
   if not isinstance(snake_case__       ,     snake_case__	) or len(snake_case__	) == 0:
      raise ValueError('the string should be not empty string'	)

   if not isinstance(snake_case__       ,     snake_case__	) or not all(
       isinstance(snake_case__       ,     snake_case__	) and len(snake_case__	) > 0 for item in words	):
      raise ValueError('the words should be a list of non-empty strings'	)

   # Build trie
   UpperCamelCase    :  dict[str, Any]							=	{}
   UpperCamelCase    :  List[str]							=	'WORD_KEEPER'

   for word in words:
      UpperCamelCase    :  List[str]							=	trie
      for c in word:
         if c not in trie_node:
            UpperCamelCase    :  int							=	{}

         UpperCamelCase    :  str							=	trie_node[c]

      UpperCamelCase    :  Tuple							=	True

   UpperCamelCase    :  List[Any]							=	len(snake_case__	)

   # Dynamic programming method
   @functools.cache
   def is_breakable(snake_case__       :    int	) -> bool:
      if index == len_string:
         return True

      UpperCamelCase    :  Dict							=	trie
      for i in range(snake_case__       ,     snake_case__	):
         UpperCamelCase    :  List[Any]							=	trie_node.get(string[i]       ,     snake_case__	)

         if trie_node is None:
            return False

         if trie_node.get(snake_case__       ,     snake_case__	) and is_breakable(i + 1	):
            return True

      return False

   return is_breakable(0	)


if __name__ == "__main__":
    import doctest

    doctest.testmod()



