

import gc
import random
import unittest

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

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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 __UpperCamelCase     (				_a					,_a					,unittest.TestCase		):






					'''simple docstring'''



					__magic_name__        =   CycleDiffusionPipeline
					__magic_name__        =   TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
					    "negative_prompt",
					    "height",
					    "width",
					    "negative_prompt_embeds",
					}
					__magic_name__        =   PipelineTesterMixin.required_optional_params - {"latents"}
					__magic_name__        =   TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"source_prompt"}		)
					__magic_name__        =   IMAGE_TO_IMAGE_IMAGE_PARAMS
					__magic_name__        =   IMAGE_TO_IMAGE_IMAGE_PARAMS





					def    _UpperCAmelCase    (				self						):
						torch.manual_seed(0						)
						UpperCAmelCase__:	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				,      )
						UpperCAmelCase__:	Optional[int]									= DDIMScheduler(
						    beta_start=0.00_085				,      beta_end=0.012				,      beta_schedule="scaled_linear"				,      num_train_timesteps=1_0_0_0				,      clip_sample=lowerCamelCase__				,      set_alpha_to_one=lowerCamelCase__				,      )
						torch.manual_seed(0						)
						UpperCAmelCase__:	Dict									= 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__:	Any									= 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				,      )
						UpperCAmelCase__:	Any									= CLIPTextModel(lowerCamelCase__						)
						UpperCAmelCase__:	Optional[int]									= 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    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__=0						):
						UpperCAmelCase__:	Tuple									= floats_tensor((1, 3, 3_2, 3_2)				,      rng=random.Random(lowerCamelCase__						)						).to(lowerCamelCase__						)
						UpperCAmelCase__:	Dict									= image / 2 + 0.5
						if str(lowerCamelCase__						).startswith("mps"						):
							UpperCAmelCase__:	Union[str, Any]									= torch.manual_seed(lowerCamelCase__						)
						else:
							UpperCAmelCase__:	List[Any]									= torch.Generator(device=lowerCamelCase__						).manual_seed(lowerCamelCase__						)
						UpperCAmelCase__:	Optional[int]									= {
						    "prompt": "An astronaut riding an elephant",
						    "source_prompt": "An astronaut riding a horse",
						    "image": image,
						    "generator": generator,
						    "num_inference_steps": 2,
						    "eta": 0.1,
						    "strength": 0.8,
						    "guidance_scale": 3,
						    "source_guidance_scale": 1,
						    "output_type": "numpy",
						}
						return inputs





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	List[Any]									= "cpu"  # ensure determinism for the device-dependent torch.Generator

						UpperCAmelCase__:	int									= self.get_dummy_components()
						UpperCAmelCase__:	Tuple									= CycleDiffusionPipeline(**lowerCamelCase__						)
						UpperCAmelCase__:	Any									= pipe.to(lowerCamelCase__						)
						pipe.set_progress_bar_config(disable=lowerCamelCase__						)

						UpperCAmelCase__:	Dict									= self.get_dummy_inputs(lowerCamelCase__						)
						UpperCAmelCase__:	Any									= pipe(**lowerCamelCase__						)
						UpperCAmelCase__:	Tuple									= output.images

						UpperCAmelCase__:	Any									= images[0, -3:, -3:, -1]

						assert images.shape == (1, 3_2, 3_2, 3)
						UpperCAmelCase__:	List[str]									= np.array([0.4_459, 0.4_943, 0.4_544, 0.6_643, 0.5_474, 0.4_327, 0.5_701, 0.5_959, 0.5_179]						)

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





					@unittest.skipIf(torch_device != "cuda"				,      "This test requires a GPU"						)
					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	int									= self.get_dummy_components()
						for name, module in components.items():
							if hasattr(lowerCamelCase__				,      "half"						):
								UpperCAmelCase__:	Optional[Any]									= module.half()
						UpperCAmelCase__:	Optional[Any]									= CycleDiffusionPipeline(**lowerCamelCase__						)
						UpperCAmelCase__:	List[str]									= pipe.to(lowerCamelCase__						)
						pipe.set_progress_bar_config(disable=lowerCamelCase__						)

						UpperCAmelCase__:	Optional[Any]									= self.get_dummy_inputs(lowerCamelCase__						)
						UpperCAmelCase__:	Optional[int]									= pipe(**lowerCamelCase__						)
						UpperCAmelCase__:	Optional[Any]									= output.images

						UpperCAmelCase__:	Optional[Any]									= images[0, -3:, -3:, -1]

						assert images.shape == (1, 3_2, 3_2, 3)
						UpperCAmelCase__:	List[Any]									= np.array([0.3_506, 0.4_543, 0.446, 0.4_575, 0.5_195, 0.4_155, 0.5_273, 0.518, 0.4_116]						)

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





					@skip_mps
					def    _UpperCAmelCase    (				self						):
						return super().test_save_load_local()





					@unittest.skip("non-deterministic pipeline"						)
					def    _UpperCAmelCase    (				self						):
						return super().test_inference_batch_single_identical()





					@skip_mps
					def    _UpperCAmelCase    (				self						):
						return super().test_dict_tuple_outputs_equivalent()





					@skip_mps
					def    _UpperCAmelCase    (				self						):
						return super().test_save_load_optional_components()





					@skip_mps
					def    _UpperCAmelCase    (				self						):
						return super().test_attention_slicing_forward_pass()

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






					'''simple docstring'''



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





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Optional[Any]									= load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/cycle-diffusion/black_colored_car.png"						)
						UpperCAmelCase__:	Tuple									= load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy"						)
						UpperCAmelCase__:	Optional[int]									= init_image.resize((5_1_2, 5_1_2)						)

						UpperCAmelCase__:	List[Any]									= "CompVis/stable-diffusion-v1-4"
						UpperCAmelCase__:	List[str]									= DDIMScheduler.from_pretrained(lowerCamelCase__				,      subfolder="scheduler"						)
						UpperCAmelCase__:	Optional[int]									= CycleDiffusionPipeline.from_pretrained(
						    lowerCamelCase__				,      scheduler=lowerCamelCase__				,      safety_checker=lowerCamelCase__				,      torch_dtype=torch.floataa				,      revision="fp16"						)

						pipe.to(lowerCamelCase__						)
						pipe.set_progress_bar_config(disable=lowerCamelCase__						)
						pipe.enable_attention_slicing()

						UpperCAmelCase__:	Optional[Any]									= "A black colored car"
						UpperCAmelCase__:	List[str]									= "A blue colored car"

						UpperCAmelCase__:	List[str]									= torch.manual_seed(0						)
						UpperCAmelCase__:	Union[str, Any]									= pipe(
						    prompt=lowerCamelCase__				,      source_prompt=lowerCamelCase__				,      image=lowerCamelCase__				,      num_inference_steps=1_0_0				,      eta=0.1				,      strength=0.85				,      guidance_scale=3				,      source_guidance_scale=1				,      generator=lowerCamelCase__				,      output_type="np"				,      )
						UpperCAmelCase__:	Union[str, Any]									= output.images

						# the values aren't exactly equal, but the images look the same visually
						assert np.abs(image - expected_image						).max() < 5e-1





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Optional[int]									= load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/cycle-diffusion/black_colored_car.png"						)
						UpperCAmelCase__:	List[Any]									= load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy"						)
						UpperCAmelCase__:	Optional[int]									= init_image.resize((5_1_2, 5_1_2)						)

						UpperCAmelCase__:	Union[str, Any]									= "CompVis/stable-diffusion-v1-4"
						UpperCAmelCase__:	Union[str, Any]									= DDIMScheduler.from_pretrained(lowerCamelCase__				,      subfolder="scheduler"						)
						UpperCAmelCase__:	List[Any]									= CycleDiffusionPipeline.from_pretrained(lowerCamelCase__				,      scheduler=lowerCamelCase__				,      safety_checker=lowerCamelCase__						)

						pipe.to(lowerCamelCase__						)
						pipe.set_progress_bar_config(disable=lowerCamelCase__						)
						pipe.enable_attention_slicing()

						UpperCAmelCase__:	Any									= "A black colored car"
						UpperCAmelCase__:	Tuple									= "A blue colored car"

						UpperCAmelCase__:	Any									= torch.manual_seed(0						)
						UpperCAmelCase__:	Optional[Any]									= pipe(
						    prompt=lowerCamelCase__				,      source_prompt=lowerCamelCase__				,      image=lowerCamelCase__				,      num_inference_steps=1_0_0				,      eta=0.1				,      strength=0.85				,      guidance_scale=3				,      source_guidance_scale=1				,      generator=lowerCamelCase__				,      output_type="np"				,      )
						UpperCAmelCase__:	List[str]									= output.images

						assert np.abs(image - expected_image						).max() < 2e-2


import inspect
import re

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
_lowerCAmelCase  :      int			 ="""src/transformers"""


# This is to make sure the transformers module imported is the one in the repo.
_lowerCAmelCase  :      Dict			 =direct_transformers_import(PATH_TO_TRANSFORMERS)

_lowerCAmelCase  :      List[str]			 =transformers.models.auto.configuration_auto.CONFIG_MAPPING

# Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`.
# For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)`
_lowerCAmelCase  :      int			 =re.compile(r"""\[(.+?)\]\((https://huggingface\.co/.+?)\)""")


_lowerCAmelCase  :      Union[str, Any]			 ={
    """DecisionTransformerConfig""",
    """EncoderDecoderConfig""",
    """MusicgenConfig""",
    """RagConfig""",
    """SpeechEncoderDecoderConfig""",
    """TimmBackboneConfig""",
    """VisionEncoderDecoderConfig""",
    """VisionTextDualEncoderConfig""",
    """LlamaConfig""",
}



def 			_A	(      SCREAMING_SNAKE_CASE      ):
	UpperCAmelCase__:	str									= None

	# source code of `config_class`
	UpperCAmelCase__:	Optional[int]									= inspect.getsource(SCREAMING_SNAKE_CASE      )
	UpperCAmelCase__:	List[Any]									= _re_checkpoint.findall(SCREAMING_SNAKE_CASE      )

	# Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
	# For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')`
	for ckpt_name, ckpt_link in checkpoints:
		# allow the link to end with `/`
		if ckpt_link.endswith("/"      ):
			UpperCAmelCase__:	Any									= ckpt_link[:-1]

		# verify the checkpoint name corresponds to the checkpoint link
		UpperCAmelCase__:	int									= f"https://huggingface.co/{ckpt_name}"
		if ckpt_link == ckpt_link_from_name:
			UpperCAmelCase__:	Optional[int]									= ckpt_name
			break

	return checkpoint



def 			_A	(      ):
	UpperCAmelCase__:	List[str]									= []

	for config_class in list(CONFIG_MAPPING.values()      ):
		# Skip deprecated models
		if "models.deprecated" in config_class.__module__:
			continue
		UpperCAmelCase__:	Optional[Any]									= get_checkpoint_from_config_class(SCREAMING_SNAKE_CASE      )

		UpperCAmelCase__:	List[str]									= config_class.__name__
		if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
			configs_without_checkpoint.append(SCREAMING_SNAKE_CASE      )

	if len(SCREAMING_SNAKE_CASE      ) > 0:
		UpperCAmelCase__:	Dict									= "\n".join(sorted(SCREAMING_SNAKE_CASE      )      )
		raise ValueError(f"The following configurations don't contain any valid checkpoint:\n{message}"      )


if __name__ == "__main__":
					check_config_docstrings_have_checkpoints()