
"""simple docstring"""



from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching


def  _UpperCamelCase	(						)    ->  List[str]:





    """simple docstring"""

    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

    _UpperCAmelCase          =   """__test_patch_submodule_mock__"""
    with patch_submodule(_test_patching					,      """os.path.join"""					,      _A      ):
        # 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  _UpperCamelCase	(						)    ->  List[str]:





    """simple docstring"""

    assert _test_patching.open is open

    _UpperCAmelCase          =   """__test_patch_submodule_builtin_mock__"""
    # _test_patching has "open" in its globals
    assert _test_patching.open is open
    with patch_submodule(_test_patching					,      """open"""					,      _A      ):
        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  _UpperCamelCase	(						)    ->  Union[str, Any]:





    """simple docstring"""

    _UpperCAmelCase          =   """__test_patch_submodule_missing_mock__"""
    with patch_submodule(_test_patching					,      """pandas.read_csv"""					,      _A      ):
        pass


def  _UpperCamelCase	(						)    ->  int:





    """simple docstring"""

    _UpperCAmelCase          =   """__test_patch_submodule_missing_builtin_mock__"""
    # _test_patching doesn't have "len" in its globals
    assert getattr(_test_patching					,      """len"""					,      _A      ) is None
    with patch_submodule(_test_patching					,      """len"""					,      _A      ):
        assert _test_patching.len is mock
    assert _test_patching.len is len


def  _UpperCamelCase	(						)    ->  str:





    """simple docstring"""

    _UpperCAmelCase          =   """__test_patch_submodule_start_and_stop_mock__"""
    _UpperCAmelCase          =   patch_submodule(_test_patching					,      """open"""					,      _A      )
    assert _test_patching.open is open
    patch.start()
    assert _test_patching.open is mock
    patch.stop()
    assert _test_patching.open is open


def  _UpperCamelCase	(						)    ->  List[Any]:





    """simple docstring"""

    from os import rename as original_rename
    from os.path import dirname as original_dirname
    from os.path import join as original_join

    _UpperCAmelCase          =   """__test_patch_submodule_successive_join__"""
    _UpperCAmelCase          =   """__test_patch_submodule_successive_dirname__"""
    _UpperCAmelCase          =   """__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"""					,      _A      ):
        with patch_submodule(_test_patching					,      """os.rename"""					,      _A      ):
            with patch_submodule(_test_patching					,      """os.path.dirname"""					,      _A      ):
                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"""					,      _A      ):
        with patch_submodule(_test_patching					,      """os.path.join"""					,      _A      ):
            with patch_submodule(_test_patching					,      """os.path.dirname"""					,      _A      ):
                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  _UpperCamelCase	(						)    ->  Optional[Any]:





    """simple docstring"""

    _UpperCAmelCase          =   """__test_patch_submodule_doesnt_exist_mock__"""
    with patch_submodule(_test_patching					,      """__module_that_doesn_exist__.__attribute_that_doesn_exist__"""					,      _A      ):
        pass
    with patch_submodule(_test_patching					,      """os.__attribute_that_doesn_exist__"""					,      _A      ):
        pass

"""simple docstring"""



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 		a_						( unittest.TestCase	):







    @property
    def      _snake_case					(			self			:       Dict     )		->int:






        '''simple docstring'''






        torch.manual_seed(0     )
        _UpperCAmelCase          =   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      _snake_case					(			self			:       Optional[Any]     )		->str:






        '''simple docstring'''






        torch.manual_seed(0     )
        _UpperCAmelCase          =   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      _snake_case					(			self			:       List[Any]     )		->Optional[int]:






        '''simple docstring'''






        torch.manual_seed(0     )
        _UpperCAmelCase          =   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=10_00     ,					)
        return CLIPTextModel(__UpperCamelCase     )







    def      _snake_case					(			self			:       List[str]     )		->Optional[Any]:






        '''simple docstring'''






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

        _UpperCAmelCase          =   LDMPipeline(unet=__UpperCamelCase     ,					vqvae=__UpperCamelCase     ,					scheduler=__UpperCamelCase     )
        ldm.to(__UpperCamelCase     )
        ldm.set_progress_bar_config(disable=__UpperCamelCase     )

        _UpperCAmelCase          =   torch.manual_seed(0     )
        _UpperCAmelCase          =   ldm(generator=__UpperCamelCase     ,					num_inference_steps=2     ,					output_type="""numpy"""     ).images

        _UpperCAmelCase          =   torch.manual_seed(0     )
        _UpperCAmelCase          =   ldm(generator=__UpperCamelCase     ,					num_inference_steps=2     ,					output_type="""numpy"""     ,					return_dict=__UpperCamelCase     )[0]

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

        assert image.shape == (1, 64, 64, 3)
        _UpperCAmelCase          =   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]     )
        _UpperCAmelCase          =   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 		a_						( unittest.TestCase	):







    def      _snake_case					(			self			:       List[Any]     )		->Optional[Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""     )
        ldm.to(__UpperCamelCase     )
        ldm.set_progress_bar_config(disable=__UpperCamelCase     )

        _UpperCAmelCase          =   torch.manual_seed(0     )
        _UpperCAmelCase          =   ldm(generator=__UpperCamelCase     ,					num_inference_steps=5     ,					output_type="""numpy"""     ).images

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

        assert image.shape == (1, 2_56, 2_56, 3)
        _UpperCAmelCase          =   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]     )
        _UpperCAmelCase          =   1e-2 if torch_device != """mps""" else 3e-2

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