


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

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,
    assert_mean_pixel_difference,
)


enable_full_determinism()
class 				SCREAMING_SNAKE_CASE__						(       lowercase__		,					lowercase__		,					lowercase__		,					unittest.TestCase    ):
      snake_case__       :  Union[str, Any]       =	StableUnCLIPPipeline
      snake_case__       :  List[Any]       =	TEXT_TO_IMAGE_PARAMS
      snake_case__       :  Optional[Any]       =	TEXT_TO_IMAGE_BATCH_PARAMS
      snake_case__       :  Any       =	TEXT_TO_IMAGE_IMAGE_PARAMS
      snake_case__       :  int       =	TEXT_TO_IMAGE_IMAGE_PARAMS

      # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
      snake_case__       :  Union[str, Any]       =	False
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    List[Any]:
             a_      :	List[Any]							=						3_2
             a_      :	List[str]							=						embedder_hidden_size

             # prior components

             torch.manual_seed(0  )
             a_      :	Dict							=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

             torch.manual_seed(0  )
             a_      :	Dict							=						CLIPTextModelWithProjection(
                 CLIPTextConfig(
                     bos_token_id=0  ,							eos_token_id=2  ,							hidden_size=SCREAMING_SNAKE_CASE__  ,							projection_dim=SCREAMING_SNAKE_CASE__  ,							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  ,							)  )

             torch.manual_seed(0  )
             a_      :	Union[str, Any]							=						PriorTransformer(
                 num_attention_heads=2  ,							attention_head_dim=1_2  ,							embedding_dim=SCREAMING_SNAKE_CASE__  ,							num_layers=1  ,							)

             torch.manual_seed(0  )
             a_      :	Optional[Any]							=						DDPMScheduler(
                 variance_type='fixed_small_log'  ,							prediction_type='sample'  ,							num_train_timesteps=1_0_0_0  ,							clip_sample=SCREAMING_SNAKE_CASE__  ,							clip_sample_range=5.0  ,							beta_schedule='squaredcos_cap_v2'  ,							)

             # regular denoising components

             torch.manual_seed(0  )
             a_      :	Optional[Any]							=						StableUnCLIPImageNormalizer(embedding_dim=SCREAMING_SNAKE_CASE__  )
             a_      :	List[str]							=						DDPMScheduler(beta_schedule='squaredcos_cap_v2'  )

             torch.manual_seed(0  )
             a_      :	List[Any]							=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

             torch.manual_seed(0  )
             a_      :	int							=						CLIPTextModel(
                 CLIPTextConfig(
                     bos_token_id=0  ,							eos_token_id=2  ,							hidden_size=SCREAMING_SNAKE_CASE__  ,							projection_dim=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  ,							)  )

             torch.manual_seed(0  )
             a_      :	Any							=						UNetaDConditionModel(
                 sample_size=3_2  ,							in_channels=4  ,							out_channels=4  ,							down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')  ,							up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')  ,							block_out_channels=(3_2, 6_4)  ,							attention_head_dim=(2, 4)  ,							class_embed_type='projection'  ,							projection_class_embeddings_input_dim=embedder_projection_dim * 2  ,							cross_attention_dim=SCREAMING_SNAKE_CASE__  ,							layers_per_block=1  ,							upcast_attention=SCREAMING_SNAKE_CASE__  ,							use_linear_projection=SCREAMING_SNAKE_CASE__  ,							)

             torch.manual_seed(0  )
             a_      :	List[str]							=						DDIMScheduler(
                 beta_schedule='scaled_linear'  ,							beta_start=0.00085  ,							beta_end=0.012  ,							prediction_type='v_prediction'  ,							set_alpha_to_one=SCREAMING_SNAKE_CASE__  ,							steps_offset=1  ,							)

             torch.manual_seed(0  )
             a_      :	Optional[Any]							=						AutoencoderKL()

             a_      :	Optional[int]							=						{
                 # prior components
                 'prior_tokenizer': prior_tokenizer,
                 'prior_text_encoder': prior_text_encoder,
                 'prior': prior,
                 'prior_scheduler': prior_scheduler,
                 # image noising components
                 'image_normalizer': image_normalizer,
                 'image_noising_scheduler': image_noising_scheduler,
                 # regular denoising components
                 'tokenizer': tokenizer,
                 'text_encoder': text_encoder,
                 'unet': unet,
                 'scheduler': scheduler,
                 'vae': vae,
             }

             return components
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  ,							SCREAMING_SNAKE_CASE__       : Optional[Any]  ,							SCREAMING_SNAKE_CASE__       : Any=0  )	->    Dict:
             if str(SCREAMING_SNAKE_CASE__  ).startswith('mps'  ):
                    a_      :	List[Any]							=						torch.manual_seed(SCREAMING_SNAKE_CASE__  )
             else:
                    a_      :	str							=						torch.Generator(device=SCREAMING_SNAKE_CASE__  ).manual_seed(SCREAMING_SNAKE_CASE__  )
             a_      :	Optional[Any]							=						{
                 'prompt': 'A painting of a squirrel eating a burger',
                 'generator': generator,
                 'num_inference_steps': 2,
                 'prior_num_inference_steps': 2,
                 'output_type': 'numpy',
             }
             return inputs
      def  SCREAMING_SNAKE_CASE							( self       : Tuple  )	->    Optional[int]:
             a_      :	str							=						torch_device == 'cpu'

             self._test_attention_slicing_forward_pass(test_max_difference=SCREAMING_SNAKE_CASE__  )

      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    Optional[Any]:
             a_      :	List[str]							=						torch_device in ['cpu', 'mps']

             self._test_inference_batch_single_identical(test_max_difference=SCREAMING_SNAKE_CASE__  )
@slow
@require_torch_gpu
class 				SCREAMING_SNAKE_CASE__						(       unittest.TestCase    ):
      def  SCREAMING_SNAKE_CASE							( self       : Optional[Any]  )	->    Dict:
             # clean up the VRAM after each test
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    Dict:
             a_      :	Dict							=						load_numpy(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'  )

             a_      :	Tuple							=						StableUnCLIPPipeline.from_pretrained('fusing/stable-unclip-2-1-l'  ,							torch_dtype=torch.floataa  )
             pipe.to(SCREAMING_SNAKE_CASE__  )
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__  )
             # stable unclip will oom when integration tests are run on a V100,
             # so turn on memory savings
             pipe.enable_attention_slicing()
             pipe.enable_sequential_cpu_offload()

             a_      :	Optional[Any]							=						torch.Generator(device='cpu'  ).manual_seed(0  )
             a_      :	Optional[Any]							=						pipe('anime turle'  ,							generator=SCREAMING_SNAKE_CASE__  ,							output_type='np'  )

             a_      :	Union[str, Any]							=						output.images[0]

             assert image.shape == (7_6_8, 7_6_8, 3)

             assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__  ,							SCREAMING_SNAKE_CASE__  )

      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    Any:
             torch.cuda.empty_cache()
             torch.cuda.reset_max_memory_allocated()
             torch.cuda.reset_peak_memory_stats()

             a_      :	Optional[int]							=						StableUnCLIPPipeline.from_pretrained('fusing/stable-unclip-2-1-l'  ,							torch_dtype=torch.floataa  )
             a_      :	Union[str, Any]							=						pipe.to(SCREAMING_SNAKE_CASE__  )
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__  )
             pipe.enable_attention_slicing()
             pipe.enable_sequential_cpu_offload()

             a_      :	str							=						pipe(
                 'anime turtle'  ,							prior_num_inference_steps=2  ,							num_inference_steps=2  ,							output_type='np'  ,							)

             a_      :	Optional[Any]							=						torch.cuda.max_memory_allocated()
             # make sure that less than 7 GB is allocated
             assert mem_bytes < 7 * 1_0**9






import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property
@unittest.skipUnless(os.path.exists(lowercase__    )		,					'''Tatoeba directory does not exist.'''    )
class 				SCREAMING_SNAKE_CASE__						(       unittest.TestCase    ):
      @cached_property
      def  SCREAMING_SNAKE_CASE							( self       : str  )	->    List[Any]:
             a_      :	Optional[Any]							=						tempfile.mkdtemp()
             return TatoebaConverter(save_dir=SCREAMING_SNAKE_CASE__  )
      @slow
      def  SCREAMING_SNAKE_CASE							( self       : List[Any]  )	->    Optional[Any]:
             self.resolver.convert_models(['heb-eng']  )

      @slow
      def  SCREAMING_SNAKE_CASE							( self       : int  )	->    Any:
             a_							,	a_      :	Dict							=						self.resolver.write_model_card('opus-mt-he-en'  ,							dry_run=SCREAMING_SNAKE_CASE__  )
             assert mmeta["long_pair"] == "heb-eng"


