


'''simple docstring'''






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    __magic_name__				(						lowerCAmelCase   ,lowerCAmelCase   ,unittest.TestCase							):
       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      lowerCAmelCase						(     self)		->    Any:




          '''simple docstring'''
          torch.manual_seed(0)
          _UpperCAmelCase  :  Optional[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')    ,				cross_attention_dim=3_2    ,				)
          _UpperCAmelCase  :  Tuple				       =DDIMScheduler(
              beta_start=0.0_00_85    ,				beta_end=0.0_12    ,				beta_schedule='scaled_linear'    ,				clip_sample=snake_case    ,				set_alpha_to_one=snake_case    ,				)
          torch.manual_seed(0)
          _UpperCAmelCase  :  str				       =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    ,				)
          torch.manual_seed(0)
          _UpperCAmelCase  :  Optional[Any]				       =CLIPTextConfig(
              bos_token_id=0    ,				eos_token_id=2    ,				hidden_size=3_2    ,				intermediate_size=3_7    ,				layer_norm_eps=1E-0_5    ,				num_attention_heads=4    ,				num_hidden_layers=5    ,				pad_token_id=1    ,				vocab_size=1_0_0_0    ,				)
          _UpperCAmelCase  :  Optional[int]				       =CLIPTextModel(snake_case)
          _UpperCAmelCase  :  Union[str, Any]				       =CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

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






       def      lowerCAmelCase						(     self    ,				snake_case    ,				snake_case=0)		->    Optional[Any]:




          '''simple docstring'''
          if str(snake_case).startswith('mps'):
             _UpperCAmelCase  :  Optional[int]				       =torch.manual_seed(snake_case)
          else:
             _UpperCAmelCase  :  Dict				       =torch.Generator(device=snake_case).manual_seed(snake_case)
          _UpperCAmelCase  :  Optional[int]				       ={
              'prompt': '.',
              'generator': generator,
              'num_inference_steps': 2,
              'guidance_scale': 1.0,
              'sag_scale': 1.0,
              'output_type': 'numpy',
          }
          return inputs






       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          super().test_inference_batch_single_identical(expected_max_diff=3E-3)






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






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




          '''simple docstring'''
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()






       def      lowerCAmelCase						(     self)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Union[str, Any]				       =StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4')
          _UpperCAmelCase  :  Tuple				       =sag_pipe.to(snake_case)
          sag_pipe.set_progress_bar_config(disable=snake_case)

          _UpperCAmelCase  :  str				       ='.'
          _UpperCAmelCase  :  str				       =torch.manual_seed(0)
          _UpperCAmelCase  :  Optional[Any]				       =sag_pipe(
              [prompt]    ,				generator=snake_case    ,				guidance_scale=7.5    ,				sag_scale=1.0    ,				num_inference_steps=2_0    ,				output_type='np')

          _UpperCAmelCase  :  Any				       =output.images

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

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          _UpperCAmelCase  :  Optional[int]				       =np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49])

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






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




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[int]				       =StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base')
          _UpperCAmelCase  :  int				       =sag_pipe.to(snake_case)
          sag_pipe.set_progress_bar_config(disable=snake_case)

          _UpperCAmelCase  :  Dict				       ='.'
          _UpperCAmelCase  :  Union[str, Any]				       =torch.manual_seed(0)
          _UpperCAmelCase  :  Any				       =sag_pipe(
              [prompt]    ,				generator=snake_case    ,				guidance_scale=7.5    ,				sag_scale=1.0    ,				num_inference_steps=2_0    ,				output_type='np')

          _UpperCAmelCase  :  List[str]				       =output.images

          _UpperCAmelCase  :  str				       =image[0, -3:, -3:, -1]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          _UpperCAmelCase  :  Optional[int]				       =np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71])

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






       def      lowerCAmelCase						(     self)		->    Dict:




          '''simple docstring'''
          _UpperCAmelCase  :  Dict				       =StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base')
          _UpperCAmelCase  :  List[str]				       =sag_pipe.to(snake_case)
          sag_pipe.set_progress_bar_config(disable=snake_case)

          _UpperCAmelCase  :  str				       ='.'
          _UpperCAmelCase  :  int				       =torch.manual_seed(0)
          _UpperCAmelCase  :  Any				       =sag_pipe(
              [prompt]    ,				width=7_6_8    ,				height=5_1_2    ,				generator=snake_case    ,				guidance_scale=7.5    ,				sag_scale=1.0    ,				num_inference_steps=2_0    ,				output_type='np'    ,				)

          _UpperCAmelCase  :  List[str]				       =output.images

          assert image.shape == (1, 5_1_2, 7_6_8, 3)





'''simple docstring'''






from __future__ import annotations

from fractions import Fraction





def lowerCamelCase__     (		__lowerCamelCase			:				int			,       __lowerCamelCase			:				int				):







   '''simple docstring'''




   return (
       num != den and num % 1_0 == den // 1_0 and (num // 1_0) / (den % 1_0) == num / den
   )





def lowerCamelCase__     (		__lowerCamelCase			:				int				):







   '''simple docstring'''




   _UpperCAmelCase  :  Optional[int]				       =[]
   _UpperCAmelCase  :  Union[str, Any]				       =1_1
   _UpperCAmelCase  :  Union[str, Any]				       =int('1' + '0' * digit_len				)
   for num in range(__lowerCamelCase			,       __lowerCamelCase				):
      while den <= 9_9:
         if (num != den) and (num % 1_0 == den // 1_0) and (den % 1_0 != 0):
            if is_digit_cancelling(__lowerCamelCase			,       __lowerCamelCase				):
               solutions.append(f"{num}/{den}"				)
         den += 1
      num += 1
      _UpperCAmelCase  :  Optional[int]				       =1_0
   return solutions





def lowerCamelCase__     (		__lowerCamelCase			:				int = 2				):







   '''simple docstring'''




   _UpperCAmelCase  :  Any				       =1.0
   for fraction in fraction_list(__lowerCamelCase				):
      _UpperCAmelCase  :  List[str]				       =Fraction(__lowerCamelCase				)
      result *= frac.denominator / frac.numerator
   return int(__lowerCamelCase				)


if __name__ == "__main__":
 print(solution())

