






"""simple docstring"""





import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class      _lowercase (     lowerCAmelCase		,  lowerCAmelCase		,  lowerCAmelCase		,  unittest.TestCase						):
      _a   :     int								=   AltDiffusionPipeline
      _a   :     int								=   TEXT_TO_IMAGE_PARAMS
      _a   :     List[Any]								=   TEXT_TO_IMAGE_BATCH_PARAMS
      _a   :     int								=   TEXT_TO_IMAGE_IMAGE_PARAMS
      _a   :     int								=   TEXT_TO_IMAGE_IMAGE_PARAMS


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            torch.manual_seed(0						)
            __snake_case      :    List[Any]  			=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							,   )
            __snake_case      :    Any  			=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						)
            __snake_case      :    Tuple  			=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							,   )

            # TODO: address the non-deterministic text encoder (fails for save-load tests)
            # torch.manual_seed(0)
            # text_encoder_config = RobertaSeriesConfig(
            #     hidden_size=32,
            #     project_dim=32,
            #     intermediate_size=37,
            #     layer_norm_eps=1e-05,
            #     num_attention_heads=4,
            #     num_hidden_layers=5,
            #     vocab_size=5002,
            # )
            # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

            torch.manual_seed(0						)
            __snake_case      :    List[Any]  			=CLIPTextConfig(
                bos_token_id=0							,   eos_token_id=2							,   hidden_size=3_2							,   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=5_0_0_2							,   )
            __snake_case      :    Tuple  			=CLIPTextModel(a						)

            __snake_case      :    str  			=XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''						)
            __snake_case      :    int  			=7_7

            __snake_case      :    int  			={
                '''unet''': unet,
                '''scheduler''': scheduler,
                '''vae''': vae,
                '''text_encoder''': text_encoder,
                '''tokenizer''': tokenizer,
                '''safety_checker''': None,
                '''feature_extractor''': None,
            }
            return components


      def _UpperCamelCase						(    self				:	List[Any]							,   a				:	List[str]							,   a				:	List[str]=0						):





            """simple docstring"""







            if str(a						).startswith('''mps'''						):
                  __snake_case      :    Optional[int]  			=torch.manual_seed(a						)
            else:
                  __snake_case      :    List[str]  			=torch.Generator(device=a						).manual_seed(a						)
            __snake_case      :    Optional[Any]  			={
                '''prompt''': '''A painting of a squirrel eating a burger''',
                '''generator''': generator,
                '''num_inference_steps''': 2,
                '''guidance_scale''': 6.0,
                '''output_type''': '''numpy''',
            }
            return inputs


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            super().test_attention_slicing_forward_pass(expected_max_diff=3e-3						)


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            super().test_inference_batch_single_identical(expected_max_diff=3e-3						)


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			='''cpu'''  # ensure determinism for the device-dependent torch.Generator

            __snake_case      :    List[Any]  			=self.get_dummy_components()
            torch.manual_seed(0						)
            __snake_case      :    str  			=RobertaSeriesConfig(
                hidden_size=3_2							,   project_dim=3_2							,   intermediate_size=3_7							,   layer_norm_eps=1e-05							,   num_attention_heads=4							,   num_hidden_layers=5							,   vocab_size=5_0_0_2							,   )
            # TODO: remove after fixing the non-deterministic text encoder
            __snake_case      :    List[Any]  			=RobertaSeriesModelWithTransformation(a						)
            __snake_case      :    Union[str, Any]  			=text_encoder

            __snake_case      :    Any  			=AltDiffusionPipeline(**a						)
            __snake_case      :    List[Any]  			=alt_pipe.to(a						)
            alt_pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    Optional[Any]  			=self.get_dummy_inputs(a						)
            __snake_case      :    Dict  			='''A photo of an astronaut'''
            __snake_case      :    int  			=alt_pipe(**a						)
            __snake_case      :    Dict  			=output.images
            __snake_case      :    Union[str, Any]  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 6_4, 6_4, 3)
            __snake_case      :    Tuple  			=np.array(
                [0.5_7_4_8_1_6_2, 0.6_0_4_4_7_1_4_5, 0.4_8_8_2_1_2_1_7, 0.5_0_1_0_0_6_3_6, 0.5_4_3_1_1_8_5, 0.4_5_7_6_3_6_8_3, 0.4_9_6_5_7_6_9_6, 0.4_8_1_3_2_7_3_3, 0.4_7_5_7_3_0_9_3]						)

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







      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    List[str]  			='''cpu'''  # ensure determinism for the device-dependent torch.Generator

            __snake_case      :    Dict  			=self.get_dummy_components()
            __snake_case      :    Optional[int]  			=PNDMScheduler(skip_prk_steps=a						)
            torch.manual_seed(0						)
            __snake_case      :    str  			=RobertaSeriesConfig(
                hidden_size=3_2							,   project_dim=3_2							,   intermediate_size=3_7							,   layer_norm_eps=1e-05							,   num_attention_heads=4							,   num_hidden_layers=5							,   vocab_size=5_0_0_2							,   )
            # TODO: remove after fixing the non-deterministic text encoder
            __snake_case      :    int  			=RobertaSeriesModelWithTransformation(a						)
            __snake_case      :    Any  			=text_encoder
            __snake_case      :    List[Any]  			=AltDiffusionPipeline(**a						)
            __snake_case      :    Optional[int]  			=alt_pipe.to(a						)
            alt_pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    Optional[Any]  			=self.get_dummy_inputs(a						)
            __snake_case      :    Any  			=alt_pipe(**a						)
            __snake_case      :    List[str]  			=output.images
            __snake_case      :    List[str]  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 6_4, 6_4, 3)
            __snake_case      :    List[str]  			=np.array(
                [0.5_1_6_0_5_0_9_3, 0.5_7_0_7_2_4_1, 0.4_7_3_6_5_5_0_7, 0.5_0_5_7_8_8_8_6, 0.5_6_3_3_8_7_7, 0.4_6_4_2_5_0_3, 0.5_1_8_2_0_8_1, 0.4_8_7_6_3_4_8_4, 0.4_9_0_8_4_2_3_7]						)

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



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


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''							,   safety_checker=a						)
            __snake_case      :    Dict  			=alt_pipe.to(a						)
            alt_pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    Union[str, Any]  			='''A painting of a squirrel eating a burger'''
            __snake_case      :    Optional[int]  			=torch.manual_seed(0						)
            __snake_case      :    List[str]  			=alt_pipe([prompt]							,   generator=a							,   guidance_scale=6.0							,   num_inference_steps=2_0							,   output_type='''np'''						)

            __snake_case      :    Tuple  			=output.images

            __snake_case      :    List[Any]  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 5_1_2, 5_1_2, 3)
            __snake_case      :    Union[str, Any]  			=np.array([0.1_0_1_0, 0.0_8_0_0, 0.0_7_9_4, 0.0_8_8_5, 0.0_8_4_3, 0.0_7_6_2, 0.0_7_6_9, 0.0_7_2_9, 0.0_5_8_6]						)

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







      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=DDIMScheduler.from_pretrained('''BAAI/AltDiffusion'''							,   subfolder='''scheduler'''						)

            __snake_case      :    Union[str, Any]  			=AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''							,   scheduler=a							,   safety_checker=a						)
            __snake_case      :    Optional[Any]  			=alt_pipe.to(a						)
            alt_pipe.set_progress_bar_config(disable=a						)

            __snake_case      :    List[str]  			='''A painting of a squirrel eating a burger'''
            __snake_case      :    int  			=torch.manual_seed(0						)

            __snake_case      :    int  			=alt_pipe([prompt]							,   generator=a							,   num_inference_steps=2							,   output_type='''numpy'''						)
            __snake_case      :    Tuple  			=output.images

            __snake_case      :    int  			=image[0, -3:, -3:, -1]

            assert image.shape == (1, 5_1_2, 5_1_2, 3)
            __snake_case      :    List[Any]  			=np.array([0.4_0_1_9, 0.4_0_5_2, 0.3_8_1_0, 0.4_1_1_9, 0.3_9_1_6, 0.3_9_8_2, 0.4_6_5_1, 0.4_1_9_5, 0.5_3_2_3]						)

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










"""simple docstring"""





def     __lowercase					(    a :				str       ,		a :				str )					->					str:
      __snake_case      :    int  			=len(a )
      __snake_case      :    int  			=len(a )
      __snake_case      :    int  			=(
          first_str_length if first_str_length > second_str_length else second_str_length
      )
      __snake_case      :    list  			=[]
      for char_count in range(a ):
            if char_count < first_str_length:
                  output_list.append(first_str[char_count] )
            if char_count < second_str_length:
                  output_list.append(second_str[char_count] )
      return "".join(a )


if __name__ == "__main__":
    print(alternative_string_arrange("""AB""", """XYZ"""), end=""" """)


