


'''simple docstring'''



import os
from datetime import datetime as dt

from github import Github


__UpperCAmelCase      :Optional[Any]			    =       [
    "good first issue",
    "good second issue",
    "good difficult issue",
    "enhancement",
    "new pipeline/model",
    "new scheduler",
    "wip",
]




def      _a     (						):





     '''simple docstring'''






     __UpperCAmelCase     :			List[str]  							=      Github(os.environ['''GITHUB_TOKEN''']  )
     __UpperCAmelCase     :			Dict  							=      g.get_repo('''huggingface/diffusers'''  )
     __UpperCAmelCase     :			Optional[int]  							=      repo.get_issues(state='''open'''  )

     for issue in open_issues:
          __UpperCAmelCase     :			Tuple  							=      sorted(issue.get_comments()      , key=lambda _lowercase  : i.created_at      , reverse=_lowercase  )
          __UpperCAmelCase     :			Optional[int]  							=      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 >= 30
              and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()  )
          ):
               # Closes the issue after 7 days of inactivity since the Stalebot notification.
               issue.edit(state='''closed'''  )
          elif (
              "stale" in issue.get_labels()
              and last_comment is not None
              and last_comment.user.login != "github-actions[bot]"
          ):
               # Opens the issue if someone other than Stalebot commented.
               issue.edit(state='''open'''  )
               issue.remove_from_labels('''stale'''  )
          elif (
              (dt.utcnow() - issue.updated_at).days > 23
              and (dt.utcnow() - issue.created_at).days >= 30
              and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()  )
          ):
               # Post a Stalebot notification after 23 days of inactivity.
               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/diffusers/blob/main/CONTRIBUTING.md) '''
                   '''are likely to be ignored.'''  )
               issue.add_to_labels('''stale'''  )


if __name__ == "__main__":
      main()



'''simple docstring'''



import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class      a    (		_a     ,  _a     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Dict							       =       StableDiffusionXLImgaImgPipeline
     SCREAMING_SNAKE_CASE	:			Tuple							       =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       PipelineTesterMixin.required_optional_params - {"latents"}
     SCREAMING_SNAKE_CASE	:			int							       =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       IMAGE_TO_IMAGE_IMAGE_PARAMS
     SCREAMING_SNAKE_CASE	:			Any							       =       IMAGE_TO_IMAGE_IMAGE_PARAMS

     def 			lowerCamelCase__			(    self					:		Any      )						->							Any:
          torch.manual_seed(0      )
          __UpperCAmelCase     :			Optional[Any]  							=      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''')							,			attention_head_dim=(2, 4)							,			use_linear_projection=snake_case							,			addition_embed_type='''text_time'''							,			addition_time_embed_dim=8							,			transformer_layers_per_block=(1, 2)							,			projection_class_embeddings_input_dim=80							,			cross_attention_dim=64							,			)
          __UpperCAmelCase     :			int  							=      EulerDiscreteScheduler(
              beta_start=0.00_085							,			beta_end=0.012							,			steps_offset=1							,			beta_schedule='''scaled_linear'''							,			timestep_spacing='''leading'''							,			)
          torch.manual_seed(0      )
          __UpperCAmelCase     :			Tuple  							=      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     :			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=32							,			)
          __UpperCAmelCase     :			Tuple  							=      CLIPTextModel(snake_case      )
          __UpperCAmelCase     :			Optional[int]  							=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							,			local_files_only=snake_case      )

          __UpperCAmelCase     :			Optional[Any]  							=      CLIPTextModelWithProjection(snake_case      )
          __UpperCAmelCase     :			Union[str, Any]  							=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							,			local_files_only=snake_case      )

          __UpperCAmelCase     :			Tuple  							=      {
              '''unet''': unet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
              '''text_encoder_2''': text_encoder_a,
              '''tokenizer_2''': tokenizer_a,
              # "safety_checker": None,
              # "feature_extractor": None,
          }
          return components

     def 			lowerCamelCase__			(    self					:		Dict							,			snake_case					:		Optional[int]							,			snake_case					:		List[str]=0      )						->							List[str]:
          __UpperCAmelCase     :			List[str]  							=      floats_tensor((1, 3, 32, 32)							,			rng=random.Random(snake_case      )      ).to(snake_case      )
          __UpperCAmelCase     :			Optional[Any]  							=      image / 2 + 0.5
          if str(snake_case      ).startswith('''mps'''      ):
               __UpperCAmelCase     :			List[str]  							=      torch.manual_seed(snake_case      )
          else:
               __UpperCAmelCase     :			Any  							=      torch.Generator(device=snake_case      ).manual_seed(snake_case      )
          __UpperCAmelCase     :			Optional[int]  							=      {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''image''': image,
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 5.0,
              '''output_type''': '''numpy''',
              '''strength''': 0.75,
          }
          return inputs

     def 			lowerCamelCase__			(    self					:		Tuple      )						->							Optional[int]:
          __UpperCAmelCase     :			Any  							=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          __UpperCAmelCase     :			Optional[Any]  							=      self.get_dummy_components()
          __UpperCAmelCase     :			Any  							=      StableDiffusionXLImgaImgPipeline(**snake_case      )
          __UpperCAmelCase     :			Union[str, Any]  							=      sd_pipe.to(snake_case      )
          sd_pipe.set_progress_bar_config(disable=snake_case      )

          __UpperCAmelCase     :			Optional[int]  							=      self.get_dummy_inputs(snake_case      )
          __UpperCAmelCase     :			int  							=      sd_pipe(**snake_case      ).images
          __UpperCAmelCase     :			List[str]  							=      image[0, -3:, -3:, -1]

          assert image.shape == (1, 32, 32, 3)

          __UpperCAmelCase     :			Any  							=      np.array([0.4_656, 0.4_840, 0.4_439, 0.6_698, 0.5_574, 0.4_524, 0.5_799, 0.5_943, 0.5_165]      )

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

     def 			lowerCamelCase__			(    self					:		Any      )						->							int:
          super().test_attention_slicing_forward_pass(expected_max_diff=3E-3      )

     def 			lowerCamelCase__			(    self					:		Optional[Any]      )						->							Optional[int]:
          super().test_inference_batch_single_identical(expected_max_diff=3E-3      )

     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							List[Any]:
          pass






     def 			lowerCamelCase__			(    self					:		Optional[int]      )						->							int:
          __UpperCAmelCase     :			Union[str, Any]  							=      self.get_dummy_components()
          __UpperCAmelCase     :			List[Any]  							=      StableDiffusionXLImgaImgPipeline(**snake_case      )
          __UpperCAmelCase     :			Tuple  							=      sd_pipe.to(snake_case      )
          __UpperCAmelCase     :			Tuple  							=      sd_pipe.to(snake_case      )
          sd_pipe.set_progress_bar_config(disable=snake_case      )

          # forward without prompt embeds
          __UpperCAmelCase     :			Tuple  							=      self.get_dummy_inputs(snake_case      )
          __UpperCAmelCase     :			Optional[Any]  							=      3 * ['''this is a negative prompt''']
          __UpperCAmelCase     :			Optional[int]  							=      negative_prompt
          __UpperCAmelCase     :			Tuple  							=      3 * [inputs['''prompt''']]

          __UpperCAmelCase     :			Optional[Any]  							=      sd_pipe(**snake_case      )
          __UpperCAmelCase     :			int  							=      output.images[0, -3:, -3:, -1]

          # forward with prompt embeds
          __UpperCAmelCase     :			Union[str, Any]  							=      self.get_dummy_inputs(snake_case      )
          __UpperCAmelCase     :			Tuple  							=      3 * ['''this is a negative prompt''']
          __UpperCAmelCase     :			str  							=      3 * [inputs.pop('''prompt'''      )]

          (
              (
              __UpperCAmelCase
          )							,       (
              __UpperCAmelCase
          )							,       (
              __UpperCAmelCase
          )							,       (
              __UpperCAmelCase
          )							,       
          )     :			Any  							=      sd_pipe.encode_prompt(snake_case							,			negative_prompt=snake_case      )

          __UpperCAmelCase     :			Dict  							=      sd_pipe(
              **snake_case							,			prompt_embeds=snake_case							,			negative_prompt_embeds=snake_case							,			pooled_prompt_embeds=snake_case							,			negative_pooled_prompt_embeds=snake_case							,			)
          __UpperCAmelCase     :			List[str]  							=      output.images[0, -3:, -3:, -1]

          # make sure that it's equal
          assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()      ).max() < 1E-4



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


     """simple docstring"""






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							Optional[Any]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()

     def 			lowerCamelCase__			(    self					:		int							,			snake_case					:		Any							,			snake_case					:		str="cpu"							,			snake_case					:		Tuple=torch.floataa							,			snake_case					:		List[str]=0      )						->							Tuple:
          __UpperCAmelCase     :			Optional[Any]  							=      torch.Generator(device=snake_case      ).manual_seed(snake_case      )
          __UpperCAmelCase     :			int  							=      np.random.RandomState(snake_case      ).standard_normal((1, 4, 64, 64)      )
          __UpperCAmelCase     :			str  							=      torch.from_numpy(snake_case      ).to(device=snake_case							,			dtype=snake_case      )
          __UpperCAmelCase     :			str  							=      {
              '''prompt''': '''a photograph of an astronaut riding a horse''',
              '''latents''': latents,
              '''generator''': generator,
              '''num_inference_steps''': 3,
              '''guidance_scale''': 7.5,
              '''output_type''': '''numpy''',
          }
          return inputs






     def 			lowerCamelCase__			(    self					:		Union[str, Any]      )						->							List[Any]:
          __UpperCAmelCase     :			str  							=      DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''      )
          pipe.to(snake_case      )
          pipe.set_progress_bar_config(disable=snake_case      )

          __UpperCAmelCase     :			str  							=      self.get_inputs(snake_case      )
          __UpperCAmelCase     :			Dict  							=      pipe(**snake_case      ).images
          __UpperCAmelCase     :			List[str]  							=      image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 512, 512, 3)
          __UpperCAmelCase     :			Tuple  							=      np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]      )
          assert np.abs(image_slice - expected_slice      ).max() < 7E-3