


'''simple docstring'''




import pytest

from datasets.parallel import ParallelBackendConfig, parallel_backend
from datasets.utils.py_utils import map_nested

from .utils import require_dill_gt_0_3_2, require_joblibspark, require_not_windows





def   _a		(lowercase__			:   Optional[Any]						)			->			str:  # picklable for multiprocessing






     """simple docstring"""
     return i + 1





@require_dill_gt_0_3_2
@require_joblibspark
@require_not_windows
def   _a		()			->			Any:






     """simple docstring"""
     with parallel_backend('spark'						):
          assert ParallelBackendConfig.backend_name == "spark"

     __snake_case           =						[1, 2, 3]
     with pytest.raises(lowercase__						):
          with parallel_backend('unsupported backend'						):
               map_nested(lowercase__							,   lowercase__							,   num_proc=2						)

     with pytest.raises(lowercase__						):
          with parallel_backend('unsupported backend'						):
               map_nested(lowercase__							,   lowercase__							,   num_proc=-1						)





@require_dill_gt_0_3_2
@require_joblibspark
@require_not_windows
@pytest.mark.parametrize('num_proc'							,   [2, -1]						)
def   _a		(lowercase__			:   Optional[Any]						)			->			Tuple:






     """simple docstring"""
     __snake_case           =						[1, 2]
     __snake_case           =						{'a': 1, 'b': 2}
     __snake_case           =						{'a': [1, 2], 'b': [3, 4]}
     __snake_case           =						{'a': {'1': 1}, 'b': 2}
     __snake_case           =						{'a': 1, 'b': 2, 'c': 3, 'd': 4}
     __snake_case           =						[2, 3]
     __snake_case           =						{'a': 2, 'b': 3}
     __snake_case           =						{'a': [2, 3], 'b': [4, 5]}
     __snake_case           =						{'a': {'1': 2}, 'b': 3}
     __snake_case           =						{'a': 2, 'b': 3, 'c': 4, 'd': 5}

     with parallel_backend('spark'						):
          assert map_nested(lowercase__							,   lowercase__							,   num_proc=lowercase__						) == expected_map_nested_sa
          assert map_nested(lowercase__							,   lowercase__							,   num_proc=lowercase__						) == expected_map_nested_sa
          assert map_nested(lowercase__							,   lowercase__							,   num_proc=lowercase__						) == expected_map_nested_sa
          assert map_nested(lowercase__							,   lowercase__							,   num_proc=lowercase__						) == expected_map_nested_sa
          assert map_nested(lowercase__							,   lowercase__							,   num_proc=lowercase__						) == expected_map_nested_sa







'''simple docstring'''



import unittest

import numpy as np
import torch

from diffusers import KarrasVePipeline, KarrasVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()







class 		lowerCAmelCase__  ( unittest.TestCase   ):



 """simple docstring"""



 @property
 def  UpperCAmelCase__						(						self   :			int     )    ->					Optional[int]:


      """simple docstring"""




      torch.manual_seed(0     )
      __SCREAMING_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


 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.dummy_uncond_unet
      __SCREAMING_SNAKE_CASE      = KarrasVeScheduler()

      __SCREAMING_SNAKE_CASE      = KarrasVePipeline(unet=__SCREAMING_SNAKE_CASE   ,				scheduler=__SCREAMING_SNAKE_CASE     )
      pipe.to(__SCREAMING_SNAKE_CASE     )
      pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.manual_seed(0     )
      __SCREAMING_SNAKE_CASE      = pipe(num_inference_steps=2   ,				generator=__SCREAMING_SNAKE_CASE   ,				output_type="""numpy"""     ).images

      __SCREAMING_SNAKE_CASE      = torch.manual_seed(0     )
      __SCREAMING_SNAKE_CASE      = pipe(num_inference_steps=2   ,				generator=__SCREAMING_SNAKE_CASE   ,				output_type="""numpy"""   ,				return_dict=__SCREAMING_SNAKE_CASE     )[0]

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

      assert image.shape == (1, 32, 32, 3)
      __SCREAMING_SNAKE_CASE      = np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]     )

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







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



 """simple docstring"""



 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = """google/ncsnpp-celebahq-256"""
      __SCREAMING_SNAKE_CASE      = UNetaDModel.from_pretrained(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = KarrasVeScheduler()

      __SCREAMING_SNAKE_CASE      = KarrasVePipeline(unet=__SCREAMING_SNAKE_CASE   ,				scheduler=__SCREAMING_SNAKE_CASE     )
      pipe.to(__SCREAMING_SNAKE_CASE     )
      pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.manual_seed(0     )
      __SCREAMING_SNAKE_CASE      = pipe(num_inference_steps=20   ,				generator=__SCREAMING_SNAKE_CASE   ,				output_type="""numpy"""     ).images

      __SCREAMING_SNAKE_CASE      = image[0, -3:, -3:, -1]
      assert image.shape == (1, 256, 256, 3)
      __SCREAMING_SNAKE_CASE      = np.array([0.578, 0.5811, 0.5924, 0.5809, 0.587, 0.5886, 0.5861, 0.5802, 0.586]     )

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






