
'''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 			UpperCAmelCase__    (							A    ,						A    ,						unittest.TestCase			):
    lowerCAmelCase_					     =		StableDiffusionSAGPipeline
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_PARAMS
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_BATCH_PARAMS
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_IMAGE_PARAMS
    lowerCAmelCase_					     =		TEXT_TO_IMAGE_IMAGE_PARAMS
    lowerCAmelCase_					     =		False



    def 	lowerCamelCase_	(						self   :							Any  ):
          torch.manual_seed(0  )
          _lowerCamelCase					: Dict		    = 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,)
          _lowerCamelCase					: Optional[int]		    = DDIMScheduler(
              beta_start=0.00085,beta_end=0.012,beta_schedule="scaled_linear",clip_sample=__A,set_alpha_to_one=__A,)
          torch.manual_seed(0  )
          _lowerCamelCase					: int		    = 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  )
          _lowerCamelCase					: Optional[int]		    = 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,)
          _lowerCamelCase					: List[Any]		    = CLIPTextModel(__A  )
          _lowerCamelCase					: str		    = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )

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



    def 	lowerCamelCase_	(						self   :							Optional[int],__A   :							int,__A   :							Any=0  ):
          if str(__A  ).startswith("mps"  ):
                _lowerCamelCase					: Any		    = torch.manual_seed(__A  )
          else:
                _lowerCamelCase					: List[Any]		    = torch.Generator(device=__A  ).manual_seed(__A  )
          _lowerCamelCase					: Optional[Any]		    = {
              "prompt": ".",
              "generator": generator,
              "num_inference_steps": 2,
              "guidance_scale": 1.0,
              "sag_scale": 1.0,
              "output_type": "numpy",
          }
          return inputs



    def 	lowerCamelCase_	(						self   :							List[Any]  ):
          super().test_inference_batch_single_identical(expected_max_diff=3e-3  )


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



    def 	lowerCamelCase_	(						self   :							Dict  ):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



    def 	lowerCamelCase_	(						self   :							str  ):
          _lowerCamelCase					: Dict		    = StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"  )
          _lowerCamelCase					: List[str]		    = sag_pipe.to(__A  )
          sag_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: int		    = "."
          _lowerCamelCase					: Optional[Any]		    = torch.manual_seed(0  )
          _lowerCamelCase					: Optional[Any]		    = sag_pipe(
              [prompt],generator=__A,guidance_scale=7.5,sag_scale=1.0,num_inference_steps=2_0,output_type="np"  )

          _lowerCamelCase					: str		    = output.images

          _lowerCamelCase					: List[str]		    = image[0, -3:, -3:, -1]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          _lowerCamelCase					: int		    = 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 	lowerCamelCase_	(						self   :							int  ):
          _lowerCamelCase					: Union[str, Any]		    = StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"  )
          _lowerCamelCase					: str		    = sag_pipe.to(__A  )
          sag_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: List[str]		    = "."
          _lowerCamelCase					: Dict		    = torch.manual_seed(0  )
          _lowerCamelCase					: Dict		    = sag_pipe(
              [prompt],generator=__A,guidance_scale=7.5,sag_scale=1.0,num_inference_steps=2_0,output_type="np"  )

          _lowerCamelCase					: Dict		    = output.images

          _lowerCamelCase					: Dict		    = image[0, -3:, -3:, -1]

          assert image.shape == (1, 5_1_2, 5_1_2, 3)
          _lowerCamelCase					: List[str]		    = 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 	lowerCamelCase_	(						self   :							List[Any]  ):
          _lowerCamelCase					: List[str]		    = StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"  )
          _lowerCamelCase					: str		    = sag_pipe.to(__A  )
          sag_pipe.set_progress_bar_config(disable=__A  )

          _lowerCamelCase					: List[str]		    = "."
          _lowerCamelCase					: int		    = torch.manual_seed(0  )
          _lowerCamelCase					: Optional[int]		    = sag_pipe(
              [prompt],width=7_6_8,height=5_1_2,generator=__A,guidance_scale=7.5,sag_scale=1.0,num_inference_steps=2_0,output_type="np",)

          _lowerCamelCase					: Tuple		    = output.images

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







"""simple docstring"""







def      UpperCamelCase       ( _A  ,				_A )     ->       int:
				lowercase    :      int       = 1  # To kept the Calculated Value
				# Since C(n, k) = C(n, n-k)
				if k > (n - k):
								lowercase    :      List[Any]       = n - k
				# Calculate C(n,k)
				for i in range(_A ):
								result *= n - i
								result //= i + 1
				return result


def      UpperCamelCase       ( _A )     ->       int:
				return binomial_coefficient(2 * node_count  ,				_A ) // (node_count + 1)


def      UpperCamelCase       ( _A )     ->       int:
				if n < 0:
								raise ValueError("""factorial() not defined for negative values""" )
				lowercase    :      Union[str, Any]       = 1
				for i in range(1  ,				n + 1 ):
								result *= i
				return result


def      UpperCamelCase       ( _A )     ->       int:
				return catalan_number(_A ) * factorial(_A )


if __name__ == "__main__":
				_lowerCAmelCase            =	int(input('Enter the number of nodes: ').strip() or 0)
				if node_count <= 0:
								raise ValueError('We need some nodes to work with.')
				print(
				    F'Given {node_count} nodes, there are {binary_tree_count(node_count)} '
				    F'binary trees and {catalan_number(node_count)} binary search trees.'
				)
