

'''simple docstring'''



def 						__lowerCamelCase	(       __snake_case					:		int	)	->							int:






						"""simple docstring"""





						assert isinstance(_UpperCAmelCase,		_UpperCAmelCase	), f"The input value of [n={number}] is not an integer"

						if number == 1:
												return 2
						elif number < 1:
												A__					:       Optional[Any]     =f"The input value of [n={number}] has to be > 0"
												raise ValueError(_UpperCAmelCase	)
						else:
												A__					:       Optional[int]     =sylvester(number - 1	)
												A__					:       Tuple     =num - 1
												A__					:       Dict     =num
												return lower * upper + 1


if __name__ == "__main__":
		print(F"""The 8th number in Sylvester's sequence: {sylvester(8)}""")




'''simple docstring'''



import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np



class lowerCamelCase			:



			'''simple docstring'''






			def lowercase__						(				self	:						Any			)      ->		Tuple:





									'''simple docstring'''
									torch.manual_seed(0			)
									A__					:       str     =TaEncoderModel.from_pretrained("""hf-internal-testing/tiny-random-t5"""			)

									torch.manual_seed(0			)
									A__					:       int     =AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-t5"""			)

									torch.manual_seed(0			)
									A__					:       Union[str, Any]     =UNetaDConditionModel(
									    sample_size=32		,      layers_per_block=1		,      block_out_channels=[32, 64]		,      down_block_types=[
									        """ResnetDownsampleBlock2D""",
									        """SimpleCrossAttnDownBlock2D""",
									    ]		,      mid_block_type="""UNetMidBlock2DSimpleCrossAttn"""		,      up_block_types=["""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""]		,      in_channels=3		,      out_channels=6		,      cross_attention_dim=32		,      encoder_hid_dim=32		,      attention_head_dim=8		,      addition_embed_type="""text"""		,      addition_embed_type_num_heads=2		,      cross_attention_norm="""group_norm"""		,      resnet_time_scale_shift="""scale_shift"""		,      act_fn="""gelu"""		,      )
									unet.set_attn_processor(AttnAddedKVProcessor()			)  # For reproducibility tests

									torch.manual_seed(0			)
									A__					:       Dict     =DDPMScheduler(
									    num_train_timesteps=10_00		,      beta_schedule="""squaredcos_cap_v2"""		,      beta_start=0.0001		,      beta_end=0.02		,      thresholding=lowerCAmelCase_		,      dynamic_thresholding_ratio=0.95		,      sample_max_value=1.0		,      prediction_type="""epsilon"""		,      variance_type="""learned_range"""		,      )

									torch.manual_seed(0			)
									A__					:       Union[str, Any]     =IFWatermarker()

									return {
									    "text_encoder": text_encoder,
									    "tokenizer": tokenizer,
									    "unet": unet,
									    "scheduler": scheduler,
									    "watermarker": watermarker,
									    "safety_checker": None,
									    "feature_extractor": None,
									}


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





									'''simple docstring'''
									torch.manual_seed(0			)
									A__					:       List[Any]     =TaEncoderModel.from_pretrained("""hf-internal-testing/tiny-random-t5"""			)

									torch.manual_seed(0			)
									A__					:       str     =AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-t5"""			)

									torch.manual_seed(0			)
									A__					:       Dict     =UNetaDConditionModel(
									    sample_size=32		,      layers_per_block=[1, 2]		,      block_out_channels=[32, 64]		,      down_block_types=[
									        """ResnetDownsampleBlock2D""",
									        """SimpleCrossAttnDownBlock2D""",
									    ]		,      mid_block_type="""UNetMidBlock2DSimpleCrossAttn"""		,      up_block_types=["""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""]		,      in_channels=6		,      out_channels=6		,      cross_attention_dim=32		,      encoder_hid_dim=32		,      attention_head_dim=8		,      addition_embed_type="""text"""		,      addition_embed_type_num_heads=2		,      cross_attention_norm="""group_norm"""		,      resnet_time_scale_shift="""scale_shift"""		,      act_fn="""gelu"""		,      class_embed_type="""timestep"""		,      mid_block_scale_factor=1.414		,      time_embedding_act_fn="""gelu"""		,      time_embedding_dim=32		,      )
									unet.set_attn_processor(AttnAddedKVProcessor()			)  # For reproducibility tests

									torch.manual_seed(0			)
									A__					:       Optional[int]     =DDPMScheduler(
									    num_train_timesteps=10_00		,      beta_schedule="""squaredcos_cap_v2"""		,      beta_start=0.0001		,      beta_end=0.02		,      thresholding=lowerCAmelCase_		,      dynamic_thresholding_ratio=0.95		,      sample_max_value=1.0		,      prediction_type="""epsilon"""		,      variance_type="""learned_range"""		,      )

									torch.manual_seed(0			)
									A__					:       int     =DDPMScheduler(
									    num_train_timesteps=10_00		,      beta_schedule="""squaredcos_cap_v2"""		,      beta_start=0.0001		,      beta_end=0.02		,      )

									torch.manual_seed(0			)
									A__					:       List[str]     =IFWatermarker()

									return {
									    "text_encoder": text_encoder,
									    "tokenizer": tokenizer,
									    "unet": unet,
									    "scheduler": scheduler,
									    "image_noising_scheduler": image_noising_scheduler,
									    "watermarker": watermarker,
									    "safety_checker": None,
									    "feature_extractor": None,
									}


			def lowercase__						(				self	:						str			)      ->		Tuple:





									'''simple docstring'''
									A__					:       Tuple     =self.get_dummy_components()
									A__					:       str     =self.pipeline_class(**lowerCAmelCase_			)
									pipe.to(lowerCAmelCase_			)
									pipe.set_progress_bar_config(disable=lowerCAmelCase_			)

									A__					:       Optional[int]     =self.get_dummy_inputs(lowerCAmelCase_			)

									A__					:       str     =inputs["""prompt"""]
									A__					:       Optional[int]     =inputs["""generator"""]
									A__					:       Optional[Any]     =inputs["""num_inference_steps"""]
									A__					:       Union[str, Any]     =inputs["""output_type"""]

									if "image" in inputs:
															A__					:       Union[str, Any]     =inputs["""image"""]
									else:
															A__					:       List[Any]     =None

									if "mask_image" in inputs:
															A__					:       Union[str, Any]     =inputs["""mask_image"""]
									else:
															A__					:       Tuple     =None

									if "original_image" in inputs:
															A__					:       Optional[Any]     =inputs["""original_image"""]
									else:
															A__					:       Tuple     =None

									A__   ,						A__					:       Optional[Any]     =pipe.encode_prompt(lowerCAmelCase_			)

									# inputs with prompt converted to embeddings
									A__					:       Optional[int]     ={
									    """prompt_embeds""": prompt_embeds,
									    """negative_prompt_embeds""": negative_prompt_embeds,
									    """generator""": generator,
									    """num_inference_steps""": num_inference_steps,
									    """output_type""": output_type,
									}

									if image is not None:
															A__					:       int     =image

									if mask_image is not None:
															A__					:       Tuple     =mask_image

									if original_image is not None:
															A__					:       Optional[int]     =original_image

									# set all optional components to None
									for optional_component in pipe._optional_components:
															setattr(lowerCAmelCase_		,      lowerCAmelCase_		,      lowerCAmelCase_			)

									A__					:       Any     =pipe(**lowerCAmelCase_			)[0]

									with tempfile.TemporaryDirectory() as tmpdir:
															pipe.save_pretrained(lowerCAmelCase_			)
															A__					:       int     =self.pipeline_class.from_pretrained(lowerCAmelCase_			)
															pipe_loaded.to(lowerCAmelCase_			)
															pipe_loaded.set_progress_bar_config(disable=lowerCAmelCase_			)

									pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()			)  # For reproducibility tests

									for optional_component in pipe._optional_components:
															self.assertTrue(
															    getattr(lowerCAmelCase_		,      lowerCAmelCase_			) is None		,      f"`{optional_component}` did not stay set to None after loading."		,      )

									A__					:       Dict     =self.get_dummy_inputs(lowerCAmelCase_			)

									A__					:       int     =inputs["""generator"""]
									A__					:       str     =inputs["""num_inference_steps"""]
									A__					:       Optional[Any]     =inputs["""output_type"""]

									# inputs with prompt converted to embeddings
									A__					:       List[Any]     ={
									    """prompt_embeds""": prompt_embeds,
									    """negative_prompt_embeds""": negative_prompt_embeds,
									    """generator""": generator,
									    """num_inference_steps""": num_inference_steps,
									    """output_type""": output_type,
									}

									if image is not None:
															A__					:       int     =image

									if mask_image is not None:
															A__					:       int     =mask_image

									if original_image is not None:
															A__					:       Optional[int]     =original_image

									A__					:       List[str]     =pipe_loaded(**lowerCAmelCase_			)[0]

									A__					:       Union[str, Any]     =np.abs(to_np(lowerCAmelCase_			) - to_np(lowerCAmelCase_			)			).max()
									self.assertLess(lowerCAmelCase_		,      1e-4			)



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





									'''simple docstring'''
									A__					:       Union[str, Any]     =self.get_dummy_components()
									A__					:       int     =self.pipeline_class(**lowerCAmelCase_			)
									pipe.to(lowerCAmelCase_			)
									pipe.set_progress_bar_config(disable=lowerCAmelCase_			)

									A__					:       int     =self.get_dummy_inputs(lowerCAmelCase_			)
									A__					:       List[Any]     =pipe(**lowerCAmelCase_			)[0]

									with tempfile.TemporaryDirectory() as tmpdir:
															pipe.save_pretrained(lowerCAmelCase_			)
															A__					:       List[Any]     =self.pipeline_class.from_pretrained(lowerCAmelCase_			)
															pipe_loaded.to(lowerCAmelCase_			)
															pipe_loaded.set_progress_bar_config(disable=lowerCAmelCase_			)

									pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()			)  # For reproducibility tests

									A__					:       int     =self.get_dummy_inputs(lowerCAmelCase_			)
									A__					:       Tuple     =pipe_loaded(**lowerCAmelCase_			)[0]

									A__					:       Tuple     =np.abs(to_np(lowerCAmelCase_			) - to_np(lowerCAmelCase_			)			).max()
									self.assertLess(lowerCAmelCase_		,      1e-4			)

