





import unittest

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

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()

class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):


      @property
      def    a (self       :      Dict      ):





         """simple docstring"""



         torch.manual_seed(0      )
         __snake_case							       =   UNetaDModel(
             block_out_channels=(32, 64)				,			layers_per_block=2				,			sample_size=32				,			in_channels=3				,			out_channels=3				,			down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')				,			up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')				,			)
         return model


      @property
      def    a (self       :      int      ):





         """simple docstring"""



         torch.manual_seed(0      )
         __snake_case							       =   VQModel(
             block_out_channels=[32, 64]				,			in_channels=3				,			out_channels=3				,			down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']				,			up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']				,			latent_channels=3				,			)
         return model


      @property
      def    a (self       :      List[str]      ):





         """simple docstring"""



         torch.manual_seed(0      )
         __snake_case							       =   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				,			)
         return CLIPTextModel(a__      )


      def    a (self       :      int      ):





         """simple docstring"""



         __snake_case							       =   self.dummy_uncond_unet
         __snake_case							       =   DDIMScheduler()
         __snake_case							       =   self.dummy_vq_model

         __snake_case							       =   LDMPipeline(unet=a__				,			vqvae=a__				,			scheduler=a__      )
         ldm.to(a__      )
         ldm.set_progress_bar_config(disable=a__      )

         __snake_case							       =   torch.manual_seed(0      )
         __snake_case							       =   ldm(generator=a__				,			num_inference_steps=2				,			output_type='''numpy'''      ).images

         __snake_case							       =   torch.manual_seed(0      )
         __snake_case							       =   ldm(generator=a__				,			num_inference_steps=2				,			output_type='''numpy'''				,			return_dict=a__      )[0]

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

         assert image.shape == (1, 64, 64, 3)
         __snake_case							       =   np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2]      )
         __snake_case							       =   1E-2 if torch_device != '''mps''' else 3E-2

         assert np.abs(image_slice.flatten() - expected_slice      ).max() < tolerance
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < tolerance






@slow
@require_torch
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   LDMPipeline.from_pretrained('''CompVis/ldm-celebahq-256'''      )
         ldm.to(a__      )
         ldm.set_progress_bar_config(disable=a__      )

         __snake_case							       =   torch.manual_seed(0      )
         __snake_case							       =   ldm(generator=a__				,			num_inference_steps=5				,			output_type='''numpy'''      ).images

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

         assert image.shape == (1, 256, 256, 3)
         __snake_case							       =   np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7]      )
         __snake_case							       =   1E-2 if torch_device != '''mps''' else 3E-2

         assert np.abs(image_slice.flatten() - expected_slice      ).max() < tolerance








from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def lowerCamelCase__    (							)      ->				Any:
   import os as original_os
   from os import path as original_path
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join

   __snake_case							       =   '''__test_patch_submodule_mock__'''
   with patch_submodule(_test_patching       ,      '''os.path.join'''       ,      snake_case_       ):
      # Every way to access os.path.join must be patched, and the rest must stay untouched

      # check os.path.join
      assert isinstance(_test_patching.os       ,      _PatchedModuleObj       )
      assert isinstance(_test_patching.os.path       ,      _PatchedModuleObj       )
      assert _test_patching.os.path.join is mock

      # check path.join
      assert isinstance(_test_patching.path       ,      _PatchedModuleObj       )
      assert _test_patching.path.join is mock

      # check join
      assert _test_patching.join is mock

      # check that the other attributes are untouched
      assert _test_patching.os.rename is original_rename
      assert _test_patching.path.dirname is original_dirname
      assert _test_patching.os.path.dirname is original_dirname

      # Even renamed modules or objects must be patched

      # check renamed_os.path.join
      assert isinstance(_test_patching.renamed_os       ,      _PatchedModuleObj       )
      assert isinstance(_test_patching.renamed_os.path       ,      _PatchedModuleObj       )
      assert _test_patching.renamed_os.path.join is mock

      # check renamed_path.join
      assert isinstance(_test_patching.renamed_path       ,      _PatchedModuleObj       )
      assert _test_patching.renamed_path.join is mock

      # check renamed_join
      assert _test_patching.renamed_join is mock

      # check that the other attributes are untouched
      assert _test_patching.renamed_os.rename is original_rename
      assert _test_patching.renamed_path.dirname is original_dirname
      assert _test_patching.renamed_os.path.dirname is original_dirname

   # check that everthing is back to normal when the patch is over

   assert _test_patching.os is original_os
   assert _test_patching.path is original_path
   assert _test_patching.join is original_join

   assert _test_patching.renamed_os is original_os
   assert _test_patching.renamed_path is original_path
   assert _test_patching.renamed_join is original_join






def lowerCamelCase__    (							)      ->				Any:
   assert _test_patching.open is open

   __snake_case							       =   '''__test_patch_submodule_builtin_mock__'''
   # _test_patching has "open" in its globals
   assert _test_patching.open is open
   with patch_submodule(_test_patching       ,      '''open'''       ,      snake_case_       ):
      assert _test_patching.open is mock

   # check that everthing is back to normal when the patch is over

   assert _test_patching.open is open






def lowerCamelCase__    (							)      ->				List[str]:
   # pandas.read_csv is not present in _test_patching
   __snake_case							       =   '''__test_patch_submodule_missing_mock__'''
   with patch_submodule(_test_patching       ,      '''pandas.read_csv'''       ,      snake_case_       ):
      pass






def lowerCamelCase__    (							)      ->				Union[str, Any]:
   # builtin should always be mocked even if they're not in the globals
   # in case they're loaded at one point
   __snake_case							       =   '''__test_patch_submodule_missing_builtin_mock__'''
   # _test_patching doesn't have "len" in its globals
   assert getattr(_test_patching       ,      '''len'''       ,      snake_case_       ) is None
   with patch_submodule(_test_patching       ,      '''len'''       ,      snake_case_       ):
      assert _test_patching.len is mock
   assert _test_patching.len is len






def lowerCamelCase__    (							)      ->				Union[str, Any]:
   __snake_case							       =   '''__test_patch_submodule_start_and_stop_mock__'''
   __snake_case							       =   patch_submodule(_test_patching       ,      '''open'''       ,      snake_case_       )
   assert _test_patching.open is open
   patch.start()
   assert _test_patching.open is mock
   patch.stop()
   assert _test_patching.open is open






def lowerCamelCase__    (							)      ->				Optional[int]:
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   __snake_case							       =   '''__test_patch_submodule_successive_join__'''
   __snake_case							       =   '''__test_patch_submodule_successive_dirname__'''
   __snake_case							       =   '''__test_patch_submodule_successive_rename__'''
   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename

   with patch_submodule(_test_patching       ,      '''os.path.join'''       ,      snake_case_       ):
      with patch_submodule(_test_patching       ,      '''os.rename'''       ,      snake_case_       ):
         with patch_submodule(_test_patching       ,      '''os.path.dirname'''       ,      snake_case_       ):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

    # try another order
   with patch_submodule(_test_patching       ,      '''os.rename'''       ,      snake_case_       ):
      with patch_submodule(_test_patching       ,      '''os.path.join'''       ,      snake_case_       ):
         with patch_submodule(_test_patching       ,      '''os.path.dirname'''       ,      snake_case_       ):
            assert _test_patching.os.path.join is mock_join
            assert _test_patching.os.path.dirname is mock_dirname
            assert _test_patching.os.rename is mock_rename

   assert _test_patching.os.path.join is original_join
   assert _test_patching.os.path.dirname is original_dirname
   assert _test_patching.os.rename is original_rename







def lowerCamelCase__    (							)      ->				Tuple:
   __snake_case							       =   '''__test_patch_submodule_doesnt_exist_mock__'''
   with patch_submodule(_test_patching       ,      '''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''       ,      snake_case_       ):
      pass
   with patch_submodule(_test_patching       ,      '''os.__attribute_that_doesn_exist__'''       ,      snake_case_       ):
      pass

