



'''simple docstring'''




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


a     :    int      						=					False

@skip_mps
class     UpperCamelCase_				(							__magic_name__   ,  __magic_name__   ,  __magic_name__   ,  unittest.TestCase    ):
	lowercase    =				StableDiffusionAttendAndExcitePipeline
	lowercase    =				False
	lowercase    =				TEXT_TO_IMAGE_PARAMS
	lowercase    =				TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}    )
	lowercase    =				TEXT_TO_IMAGE_IMAGE_PARAMS
	lowercase    =				TEXT_TO_IMAGE_IMAGE_PARAMS





	@classmethod
	def 				_lowercase(						cls					)    ->    Tuple:
								super().setUpClass()
								torch.use_deterministic_algorithms(A					)





	@classmethod
	def 				_lowercase(						cls					)    ->    Dict:
								super().tearDownClass()
								torch.use_deterministic_algorithms(A					)





	def 				_lowercase(						self					)    ->    Optional[Any]:
								torch.manual_seed(0					)
								UpperCAmelCase  :	Optional[Any]							  =	UNetaDConditionModel(
								    block_out_channels=(32, 64)	,	layers_per_block=1	,	sample_size=32	,	in_channels=4	,	out_channels=4	,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")	,	up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")	,	cross_attention_dim=32	,	attention_head_dim=(2, 4)	,	use_linear_projection=A	,	)
								UpperCAmelCase  :	int							  =	DDIMScheduler(
								    beta_start=0.0_0_0_8_5	,	beta_end=0.0_1_2	,	beta_schedule="""scaled_linear"""	,	clip_sample=A	,	set_alpha_to_one=A	,	)
								torch.manual_seed(0					)
								UpperCAmelCase  :	Union[str, Any]							  =	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	,	sample_size=128	,	)
								torch.manual_seed(0					)
								UpperCAmelCase  :	Optional[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=1000	,	hidden_act="""gelu"""	,	projection_dim=512	,	)
								UpperCAmelCase  :	Optional[Any]							  =	CLIPTextModel(A					)
								UpperCAmelCase  :	List[str]							  =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

								UpperCAmelCase  :	Optional[int]							  =	{
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """safety_checker""": None,
								    """feature_extractor""": None,
								}

								return components





	def 				_lowercase(						self	,	A	,	A=0					)    ->    Any:
								if str(A					).startswith("""mps"""					):
															UpperCAmelCase  :	Tuple							  =	torch.manual_seed(A					)
								else:
															UpperCAmelCase  :	List[Any]							  =	torch.Generator(device=A					).manual_seed(A					)
								UpperCAmelCase  :	str							  =	{
								    """prompt""": """a cat and a frog""",
								    """token_indices""": [2, 5],
								    """generator""": generator,
								    """num_inference_steps""": 1,
								    """guidance_scale""": 6.0,
								    """output_type""": """numpy""",
								    """max_iter_to_alter""": 2,
								    """thresholds""": {0: 0.7},
								}
								return inputs





	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	List[str]							  =	"""cpu"""

								UpperCAmelCase  :	Optional[Any]							  =	self.get_dummy_components()
								UpperCAmelCase  :	Union[str, Any]							  =	self.pipeline_class(**A					)
								pipe.to(A					)
								pipe.set_progress_bar_config(disable=A					)

								UpperCAmelCase  :	Union[str, Any]							  =	self.get_dummy_inputs(A					)
								UpperCAmelCase  :	List[Any]							  =	pipe(**A					).images
								UpperCAmelCase  :	Union[str, Any]							  =	image[0, -3:, -3:, -1]

								self.assertEqual(image.shape	,	(1, 64, 64, 3)					)
								UpperCAmelCase  :	Optional[int]							  =	np.array(
								    [0.6_3_9_0_5_3_6_4, 0.6_2_8_9_7_3_0_7, 0.4_8_5_9_9_0_1_7, 0.5_1_3_3_6_2_4, 0.5_5_5_0_0_4_8, 0.4_5_7_6_9_5_1_6, 0.5_0_3_2_6_9_7_3, 0.5_0_2_3_1_3_9, 0.4_5_3_8_4_4_9_6]					)
								UpperCAmelCase  :	List[Any]							  =	np.abs(image_slice.flatten() - expected_slice					).max()
								self.assertLessEqual(A	,	1e-3					)





	def 				_lowercase(						self					)    ->    Optional[Any]:
								super().test_cpu_offload_forward_pass(expected_max_diff=5e-4					)





	def 				_lowercase(						self					)    ->    str:
								# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
								self._test_inference_batch_consistent(batch_sizes=[1, 2]					)





	def 				_lowercase(						self					)    ->    Dict:
								self._test_inference_batch_single_identical(batch_size=2	,	expected_max_diff=7e-4					)





	def 				_lowercase(						self					)    ->    List[str]:
								super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3					)





	def 				_lowercase(						self					)    ->    Optional[Any]:
								super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4					)





	def 				_lowercase(						self					)    ->    Union[str, Any]:
								super().test_save_load_local(expected_max_difference=5e-4					)






	def 				_lowercase(						self					)    ->    Optional[int]:
								super().test_save_load_optional_components(expected_max_difference=4e-4					)




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





	@classmethod
	def 				_lowercase(						cls					)    ->    Dict:
								super().setUpClass()
								torch.use_deterministic_algorithms(A					)





	@classmethod
	def 				_lowercase(						cls					)    ->    Optional[int]:
								super().tearDownClass()
								torch.use_deterministic_algorithms(A					)





	def 				_lowercase(						self					)    ->    Any:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  :	Tuple							  =	torch.manual_seed(51					)

								UpperCAmelCase  :	List[str]							  =	StableDiffusionAttendAndExcitePipeline.from_pretrained(
								    """CompVis/stable-diffusion-v1-4"""	,	safety_checker=A	,	torch_dtype=torch.floataa					)
								pipe.to("""cuda"""					)

								UpperCAmelCase  :	Dict							  =	"""a painting of an elephant with glasses"""
								UpperCAmelCase  :	str							  =	[5, 7]

								UpperCAmelCase  :	Optional[Any]							  =	pipe(
								    prompt=A	,	token_indices=A	,	guidance_scale=7.5	,	generator=A	,	num_inference_steps=5	,	max_iter_to_alter=5	,	output_type="""numpy"""	,	).images[0]

								UpperCAmelCase  :	Optional[int]							  =	load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy"""					)
								assert np.abs((expected_image - image).max()					) < 5e-1






'''simple docstring'''




from datetime import datetime as dt
import os

from github import Github


a     :    int      						=					[
    """good first issue""",
    """good second issue""",
    """good difficult issue""",
    """feature request""",
    """new model""",
    """wip""",
]



def    __lowerCamelCase						(      )   ->    Dict:
							UpperCAmelCase  :	str							  =	Github(os.environ["""GITHUB_TOKEN"""]	)
							UpperCAmelCase  :	Dict							  =	g.get_repo("""huggingface/transformers"""	)
							UpperCAmelCase  :	int							  =	repo.get_issues(state="""open"""	)

							for issue in open_issues:
														UpperCAmelCase  :	Optional[int]							  =	sorted([comment for comment in issue.get_comments()]			,       key=lambda _lowercase	: i.created_at			,       reverse=_lowercase	)
														UpperCAmelCase  :	Any							  =	comments[0] if len(_lowercase	) > 0 else None
														if (
														    last_comment is not None
														    and last_comment.user.login == "github-actions[bot]"
														    and (dt.utcnow() - issue.updated_at).days > 7
														    and (dt.utcnow() - issue.created_at).days >= 3_0
														    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()	)
														):
																					# print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
																					issue.edit(state="""closed"""	)
														elif (
														    (dt.utcnow() - issue.updated_at).days > 2_3
														    and (dt.utcnow() - issue.created_at).days >= 3_0
														    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()	)
														):
																					# print(f"Would add stale comment to {issue.number}")
																					issue.create_comment(
																					    """This issue has been automatically marked as stale because it has not had """
																					    """recent activity. If you think this still needs to be addressed """
																					    """please comment on this thread.\n\nPlease note that issues that do not follow the """
																					    """[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) """
																					    """are likely to be ignored."""	)


if __name__ == "__main__":
							main()

