



'''simple docstring'''


from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def  UpperCAmelCase_       (		):
     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

     a_       		="__test_patch_submodule_mock__"
     with patch_submodule(_test_patching       ,	"os.path.join"       ,	lowercase__       ):
          # 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_       (		):
     assert _test_patching.open is open

     a_       		="__test_patch_submodule_builtin_mock__"
     # _test_patching has "open" in its globals
     assert _test_patching.open is open
     with patch_submodule(_test_patching       ,	"open"       ,	lowercase__       ):
          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_       (		):
     a_       		="__test_patch_submodule_missing_mock__"
     with patch_submodule(_test_patching       ,	"pandas.read_csv"       ,	lowercase__       ):
          pass






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






def  UpperCAmelCase_       (		):
     a_       		="__test_patch_submodule_start_and_stop_mock__"
     a_       		=patch_submodule(_test_patching       ,	"open"       ,	lowercase__       )
     assert _test_patching.open is open
     patch.start()
     assert _test_patching.open is mock
     patch.stop()
     assert _test_patching.open is open






def  UpperCAmelCase_       (		):
     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     a_       		="__test_patch_submodule_successive_join__"
     a_       		="__test_patch_submodule_successive_dirname__"
     a_       		="__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"       ,	lowercase__       ):
          with patch_submodule(_test_patching       ,	"os.rename"       ,	lowercase__       ):
               with patch_submodule(_test_patching       ,	"os.path.dirname"       ,	lowercase__       ):
                    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"       ,	lowercase__       ):
          with patch_submodule(_test_patching       ,	"os.path.join"       ,	lowercase__       ):
               with patch_submodule(_test_patching       ,	"os.path.dirname"       ,	lowercase__       ):
                    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_       (		):
     a_       		="__test_patch_submodule_doesnt_exist_mock__"
     with patch_submodule(_test_patching       ,	"__module_that_doesn_exist__.__attribute_that_doesn_exist__"       ,	lowercase__       ):
          pass
     with patch_submodule(_test_patching       ,	"os.__attribute_that_doesn_exist__"       ,	lowercase__       ):
          pass







'''simple docstring'''


import unittest
from typing import Tuple

import torch

from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch







@require_torch
class 	UpperCAmelCase	:


 '''simple docstring'''




 @property
 def       lowercase_  (   self) ->      Any:



      """simple docstring"""







      return self.get_dummy_input()




 @property
 def       lowercase_  (   self) ->      List[str]:



      """simple docstring"""







      if self.block_type == "down":
           return (4, 3_2, 1_6, 1_6)
      elif self.block_type == "mid":
           return (4, 3_2, 3_2, 3_2)
      elif self.block_type == "up":
           return (4, 3_2, 6_4, 6_4)

      raise ValueError(f"""'{self.block_type}' is not a supported block_type. Set it to 'up', 'mid', or 'down'.""")




 def       lowercase_  (   self							,  lowerCAmelCase_=True							,  lowerCAmelCase_=False							,  lowerCAmelCase_=False							,  lowerCAmelCase_=False							,  ) ->      Dict:



      """simple docstring"""







      a_       		=4
      a_       		=3_2
      a_       		=(3_2, 3_2)

      a_       		=torch.manual_seed(0)
      a_       		=torch.device(lowerCAmelCase_)
      a_       		=(batch_size, num_channels) + sizes
      a_       		=randn_tensor(lowerCAmelCase_							,  generator=lowerCAmelCase_							,  device=lowerCAmelCase_)
      a_       		={"hidden_states": hidden_states}

      if include_temb:
           a_       		=1_2_8
           a_       		=randn_tensor((batch_size, temb_channels)							,  generator=lowerCAmelCase_							,  device=lowerCAmelCase_)

      if include_res_hidden_states_tuple:
           a_       		=torch.manual_seed(1)
           a_       		=(randn_tensor(lowerCAmelCase_							,  generator=lowerCAmelCase_							,  device=lowerCAmelCase_),)

      if include_encoder_hidden_states:
           a_       		=floats_tensor((batch_size, 3_2, 3_2)).to(lowerCAmelCase_)

      if include_skip_sample:
           a_       		=randn_tensor(((batch_size, 3) + sizes)							,  generator=lowerCAmelCase_							,  device=lowerCAmelCase_)

      return dummy_input




 def       lowercase_  (   self) ->      Optional[int]:



      """simple docstring"""







      a_       		={
          "in_channels": 3_2,
          "out_channels": 3_2,
          "temb_channels": 1_2_8,
      }
      if self.block_type == "up":
           a_       		=3_2

      if self.block_type == "mid":
           init_dict.pop("out_channels")

      a_       		=self.dummy_input
      return init_dict, inputs_dict




 def       lowercase_  (   self							,  lowerCAmelCase_) ->      Dict:



      """simple docstring"""







      a_		,						a_       		=self.prepare_init_args_and_inputs_for_common()
      a_       		=self.block_class(**lowerCAmelCase_)
      unet_block.to(lowerCAmelCase_)
      unet_block.eval()

      with torch.no_grad():
           a_       		=unet_block(**lowerCAmelCase_)

      if isinstance(lowerCAmelCase_							,  lowerCAmelCase_):
           a_       		=output[0]

      self.assertEqual(output.shape							,  self.output_shape)

      a_       		=output[0, -1, -3:, -3:]
      a_       		=torch.tensor(lowerCAmelCase_).to(lowerCAmelCase_)
      assert torch_all_close(output_slice.flatten()							,  lowerCAmelCase_							,  atol=5e-3)




 @unittest.skipIf(torch_device == "mps"							,  "Training is not supported in mps")
 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      a_		,						a_       		=self.prepare_init_args_and_inputs_for_common()
      a_       		=self.block_class(**lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.train()
      a_       		=model(**lowerCAmelCase_)

      if isinstance(lowerCAmelCase_							,  lowerCAmelCase_):
           a_       		=output[0]

      a_       		=torch.device(lowerCAmelCase_)
      a_       		=randn_tensor(output.shape							,  device=lowerCAmelCase_)
      a_       		=torch.nn.functional.mse_loss(lowerCAmelCase_							,  lowerCAmelCase_)
      loss.backward()


