import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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     _lowercase					(    UpperCamelCase_  ,							UpperCamelCase_  ,							unittest.TestCase      ):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE					:	str				     = StableDiffusionXLPipeline
 _SCREAMING_SNAKE_CASE					:	Optional[int]				     = TEXT_TO_IMAGE_PARAMS
 _SCREAMING_SNAKE_CASE					:	Dict				     = TEXT_TO_IMAGE_BATCH_PARAMS
 _SCREAMING_SNAKE_CASE					:	List[str]				     = TEXT_TO_IMAGE_IMAGE_PARAMS
 _SCREAMING_SNAKE_CASE					:	str				     = TEXT_TO_IMAGE_IMAGE_PARAMS
 def a (				self       :     int							)  ->   Any:
  torch.manual_seed(0							)
  __lowerCAmelCase    							=						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=lowercase_				,	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				,	)
  __lowerCAmelCase    							=						EulerDiscreteScheduler(
      beta_start=0.0_0_0_8_5				,	beta_end=0.0_1_2				,	steps_offset=1				,	beta_schedule="""scaled_linear"""				,	timestep_spacing="""leading"""				,	)
  torch.manual_seed(0							)
  __lowerCAmelCase    							=						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=1_28				,	)
  torch.manual_seed(0							)
  __lowerCAmelCase    							=						CLIPTextConfig(
      bos_token_id=0				,	eos_token_id=2				,	hidden_size=32				,	intermediate_size=37				,	layer_norm_eps=1e-0_5				,	num_attention_heads=4				,	num_hidden_layers=5				,	pad_token_id=1				,	vocab_size=10_00				,	hidden_act="""gelu"""				,	projection_dim=32				,	)
  __lowerCAmelCase    							=						CLIPTextModel(lowercase_							)
  __lowerCAmelCase    							=						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				,	local_files_only=lowercase_							)

  __lowerCAmelCase    							=						CLIPTextModelWithProjection(lowercase_							)
  __lowerCAmelCase    							=						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				,	local_files_only=lowercase_							)

  __lowerCAmelCase    							=						{
      '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 a (				self       :     Union[str, Any]				,	SCREAMING_SNAKE_CASE__       :     Optional[Any]				,	SCREAMING_SNAKE_CASE__       :     int=0							)  ->   Optional[Any]:




  if str(lowercase_							).startswith("""mps"""							):
   __lowerCAmelCase    							=						torch.manual_seed(lowercase_							)
  else:
   __lowerCAmelCase    							=						torch.Generator(device=lowercase_							).manual_seed(lowercase_							)
  __lowerCAmelCase    							=						{
      'prompt': 'A painting of a squirrel eating a burger',
      'generator': generator,
      'num_inference_steps': 2,
      'guidance_scale': 5.0,
      'output_type': 'numpy',
  }
  return inputs
 def a (				self       :     Tuple							)  ->   List[Any]:
  __lowerCAmelCase    							=						'cpu'  # ensure determinism for the device-dependent torch.Generator
  __lowerCAmelCase    							=						self.get_dummy_components()
  __lowerCAmelCase    							=						StableDiffusionXLPipeline(**lowercase_							)
  __lowerCAmelCase    							=						sd_pipe.to(lowercase_							)
  sd_pipe.set_progress_bar_config(disable=lowercase_							)

  __lowerCAmelCase    							=						self.get_dummy_inputs(lowercase_							)
  __lowerCAmelCase    							=						sd_pipe(**lowercase_							).images
  __lowerCAmelCase    							=						image[0, -3:, -3:, -1]

  assert image.shape == (1, 64, 64, 3)
  __lowerCAmelCase    							=						np.array([0.5_8_7_3, 0.6_1_2_8, 0.4_7_9_7, 0.5_1_2_2, 0.5_6_7_4, 0.4_6_3_9, 0.5_2_2_7, 0.5_1_4_9, 0.4_7_4_7]							)

  assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2
 def a (				self       :     Tuple							)  ->   Optional[Any]:
  __lowerCAmelCase    							=						self.get_dummy_components()
  __lowerCAmelCase    							=						StableDiffusionXLPipeline(**lowercase_							)
  __lowerCAmelCase    							=						sd_pipe.to(lowercase_							)
  __lowerCAmelCase    							=						sd_pipe.to(lowercase_							)
  sd_pipe.set_progress_bar_config(disable=lowercase_							)

  # forward without prompt embeds
  __lowerCAmelCase    							=						self.get_dummy_inputs(lowercase_							)
  __lowerCAmelCase    							=						3 * ['this is a negative prompt']
  __lowerCAmelCase    							=						negative_prompt
  __lowerCAmelCase    							=						3 * [inputs['prompt']]

  __lowerCAmelCase    							=						sd_pipe(**lowercase_							)
  __lowerCAmelCase    							=						output.images[0, -3:, -3:, -1]

  # forward with prompt embeds
  __lowerCAmelCase    							=						self.get_dummy_inputs(lowercase_							)
  __lowerCAmelCase    							=						3 * ['this is a negative prompt']
  __lowerCAmelCase    							=						3 * [inputs.pop("""prompt"""							)]

  (
      __lowerCAmelCase					
  )    							=						sd_pipe.encode_prompt(lowercase_				,	negative_prompt=lowercase_							)

  __lowerCAmelCase    							=						sd_pipe(
      **lowercase_				,	prompt_embeds=lowercase_				,	negative_prompt_embeds=lowercase_				,	pooled_prompt_embeds=lowercase_				,	negative_pooled_prompt_embeds=lowercase_				,	)
  __lowerCAmelCase    							=						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
 def a (				self       :     int							)  ->   Optional[Any]:
  super().test_attention_slicing_forward_pass(expected_max_diff=3e-3							)





 def a (				self       :     Union[str, Any]							)  ->   Optional[Any]:
  super().test_inference_batch_single_identical(expected_max_diff=3e-3							)







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


 '''simple docstring'''






 def a (				self       :     Any							)  ->   int:
  super().tearDown()
  gc.collect()
  torch.cuda.empty_cache()
 def a (				self       :     int				,	SCREAMING_SNAKE_CASE__       :     Dict				,	SCREAMING_SNAKE_CASE__       :     int="cpu"				,	SCREAMING_SNAKE_CASE__       :     Any=torch.floataa				,	SCREAMING_SNAKE_CASE__       :     List[str]=0							)  ->   int:
  __lowerCAmelCase    							=						torch.Generator(device=lowercase_							).manual_seed(lowercase_							)
  __lowerCAmelCase    							=						np.random.RandomState(lowercase_							).standard_normal((1, 4, 64, 64)							)
  __lowerCAmelCase    							=						torch.from_numpy(lowercase_							).to(device=lowercase_				,	dtype=lowercase_							)
  __lowerCAmelCase    							=						{
      '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 a (				self       :     Dict							)  ->   Union[str, Any]:
  __lowerCAmelCase    							=						DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""							)
  pipe.to(lowercase_							)
  pipe.set_progress_bar_config(disable=lowercase_							)

  __lowerCAmelCase    							=						self.get_inputs(lowercase_							)
  __lowerCAmelCase    							=						pipe(**lowercase_							).images
  __lowerCAmelCase    							=						image[0, -3:, -3:, -1].flatten()

  assert image.shape == (1, 5_12, 5_12, 3)
  __lowerCAmelCase    							=						np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6]							)
  assert np.abs(image_slice - expected_slice							).max() < 7e-3







'''simple docstring'''

import argparse

from transformers import CanineConfig, CanineModel, CanineTokenizer, load_tf_weights_in_canine
from transformers.utils import logging


logging.set_verbosity_info()







def 					UpperCamelCase_						( snake_case_	:	List[str]						,		snake_case_	:	Optional[Any]				) ->					Tuple:






 '''simple docstring'''

 __lowerCAmelCase    							=						CanineConfig()
 __lowerCAmelCase    							=						CanineModel(snake_case_				)
 model.eval()

 print(f"""Building PyTorch model from configuration: {config}"""				)

 # Load weights from tf checkpoint
 load_tf_weights_in_canine(snake_case_						,		snake_case_						,		snake_case_				)

 # Save pytorch-model (weights and configuration)
 print(f"""Save PyTorch model to {pytorch_dump_path}"""				)
 model.save_pretrained(snake_case_				)

 # Save tokenizer files
 __lowerCAmelCase    							=						CanineTokenizer()
 print(f"""Save tokenizer files to {pytorch_dump_path}"""				)
 tokenizer.save_pretrained(snake_case_				)


if __name__ == "__main__":
 _A      :				int 				=    argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--tf_checkpoint_path''',
     default=None,
     type=str,
     required=True,
     help='''Path to the TensorFlow checkpoint. Should end with model.ckpt''',
 )
 parser.add_argument(
     '''--pytorch_dump_path''',
     default=None,
     type=str,
     required=True,
     help='''Path to a folder where the PyTorch model will be placed.''',
 )
 _A      :				Dict 				=    parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.pytorch_dump_path)






