




import time
from dataclasses import dataclass
from multiprocessing import Pool
from unittest import TestCase
from unittest.mock import patch

import multiprocess
import numpy as np
import pytest

from datasets.utils.py_utils import (
    NestedDataStructure,
    asdict,
    iflatmap_unordered,
    map_nested,
    temp_seed,
    temporary_assignment,
    zip_dict,
)

from .utils import require_tf, require_torch
def      a_ (      _A  )			->			Optional[Any]:  # picklable for multiprocessing







				"""simple docstring"""
				return x.sum()
def      a_ (      _A  )			->			Any:  # picklable for multiprocessing







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


@dataclass
class   __SCREAMING_SNAKE_CASE:
							_UpperCAmelCase     =       4_2
							_UpperCAmelCase     =       4_2


class   __SCREAMING_SNAKE_CASE(	a_	):
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		List[str]:
											snake_case__									=     {}
											snake_case__									=     []
											snake_case__									=     1
											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__									=     {}
											snake_case__									=     []
											snake_case__									=     2
											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}
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase						)       ,	_lowerCAmelCase						)

											snake_case__									=     2
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)

											snake_case__									=     {'a': np.eye(2						), 'b': np.zeros(3						), 'c': np.ones(2						)}
											snake_case__									=     {'a': 2, 'b': 0, 'c': 2}
											snake_case__									=     {
											    'a': np.eye(2						).astype(_lowerCAmelCase						),
											    'b': np.zeros(3						).astype(_lowerCAmelCase						),
											    'c': np.ones(2						).astype(_lowerCAmelCase						),
											}
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	map_numpy=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(
											    {k: v.tolist() for k, v in map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	map_numpy=_lowerCAmelCase						).items()}       ,	{k: v.tolist() for k, v in expected_map_nested_sna_int.items()}       ,	)
											self.assertEqual(map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	map_numpy=_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)       ,	_lowerCAmelCase						)
											self.assertEqual(
											    {k: v.tolist() for k, v in map_nested(_lowerCAmelCase       ,	_lowerCAmelCase       ,	map_numpy=_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						).items()}       ,	{k: v.tolist() for k, v in expected_map_nested_sna_int.items()}       ,	)
											with self.assertRaises(_lowerCAmelCase						):  # can't pickle a local lambda
															map_nested(lambda UpperCamelCase						: x + 1       ,	_lowerCAmelCase       ,	num_proc=_lowerCAmelCase						)
							def lowerCAmelCase_ (     self:      Tuple						)		->		List[Any]:
											snake_case__									=     {'a': 1, 'b': 2}
											snake_case__									=     {'a': 3, 'b': 4}
											snake_case__									=     {'a': 5, 'b': 6}
											snake_case__									=     sorted([('a', (1, 3, 5)), ('b', (2, 4, 6))]						)
											self.assertEqual(sorted(zip_dict(_lowerCAmelCase       ,	_lowerCAmelCase       ,	_lowerCAmelCase						)						)       ,	_lowerCAmelCase						)


							def lowerCAmelCase_ (     self:      List[Any]						)		->		int:


											class   __SCREAMING_SNAKE_CASE:
																		_UpperCAmelCase     =       "bar"


											snake_case__									=     Foo()
											self.assertEqual(foo.my_attr       ,	'bar'						)
											with temporary_assignment(_lowerCAmelCase       ,	'my_attr'       ,	'BAR'						):
															self.assertEqual(foo.my_attr       ,	'BAR'						)
											self.assertEqual(foo.my_attr       ,	'bar'						)


@pytest.mark.parametrize(
    'iterable_length, num_proc, expected_num_proc'      ,   [
        (1, None, 1),
        (1, 1, 1),
        (2, None, 1),
        (2, 1, 1),
        (2, 2, 1),
        (2, 3, 1),
        (3, 2, 1),
        (16, 16, 16),
        (16, 17, 16),
        (17, 16, 16),
    ]      ,   )
def      a_ (      _A      ,   _A      ,   _A  )			->			str:







				"""simple docstring"""
				with patch('datasets.utils.py_utils._single_map_nested'  ) as mock_single_map_nested, patch(
				    'datasets.parallel.parallel.Pool'  ) as mock_multiprocessing_pool:
								snake_case__									=     {f'''{i}''': i for i in range(__lowerCAmelCase  )}
								snake_case__									=     map_nested(lambda _A  : x + 10      ,   __lowerCAmelCase      ,   num_proc=__lowerCAmelCase      ,   parallel_min_length=16  )
								if expected_num_proc == 1:
												assert mock_single_map_nested.called
												assert not mock_multiprocessing_pool.called
								else:
												assert not mock_single_map_nested.called
												assert mock_multiprocessing_pool.called
												assert mock_multiprocessing_pool.call_args[0][0] == expected_num_proc


class   __SCREAMING_SNAKE_CASE(	a_	):
							@require_tf
							def lowerCAmelCase_ (     self:      Tuple						)		->		int:
											import tensorflow as tf
											from tensorflow.keras import layers

											snake_case__									=     layers.Dense(2						)

											def gen_random_output():
															snake_case__									=     tf.random.uniform((1, 3)						)
															return model(_lowerCAmelCase						).numpy()

											with temp_seed(42       ,	set_tensorflow=_lowerCAmelCase						):
															snake_case__									=     gen_random_output()
											with temp_seed(42       ,	set_tensorflow=_lowerCAmelCase						):
															snake_case__									=     gen_random_output()
											snake_case__									=     gen_random_output()

											np.testing.assert_equal(_lowerCAmelCase       ,	_lowerCAmelCase						)
											self.assertGreater(np.abs(outa - outa						).sum()       ,	0						)
							@require_torch
							def lowerCAmelCase_ (     self:      Any						)		->		Optional[int]:
											import torch

											def gen_random_output():
															snake_case__									=     torch.nn.Linear(3       ,	2						)
															snake_case__									=     torch.rand(1       ,	3						)
															return model(_lowerCAmelCase						).detach().numpy()

											with temp_seed(42       ,	set_pytorch=_lowerCAmelCase						):
															snake_case__									=     gen_random_output()
											with temp_seed(42       ,	set_pytorch=_lowerCAmelCase						):
															snake_case__									=     gen_random_output()
											snake_case__									=     gen_random_output()

											np.testing.assert_equal(_lowerCAmelCase       ,	_lowerCAmelCase						)
											self.assertGreater(np.abs(outa - outa						).sum()       ,	0						)


							def lowerCAmelCase_ (     self:      List[Any]						)		->		Optional[Any]:
											def gen_random_output():
															return np.random.rand(1       ,	3						)

											with temp_seed(42						):
															snake_case__									=     gen_random_output()
											with temp_seed(42						):
															snake_case__									=     gen_random_output()
											snake_case__									=     gen_random_output()

											np.testing.assert_equal(_lowerCAmelCase       ,	_lowerCAmelCase						)
											self.assertGreater(np.abs(outa - outa						).sum()       ,	0						)


@pytest.mark.parametrize('input_data'      ,   [{}]  )
def      a_ (      _A  )			->			Optional[Any]:







				"""simple docstring"""
				snake_case__									=     NestedDataStructure(__lowerCAmelCase  ).data
				assert output_data == input_data
@pytest.mark.parametrize(
    'data, expected_output'      ,   [
        ({}, []),
        ([], []),
        ('foo', ['foo']),
        (['foo', 'bar'], ['foo', 'bar']),
        ([['foo', 'bar']], ['foo', 'bar']),
        ([[['foo'], ['bar']]], ['foo', 'bar']),
        ([[['foo'], 'bar']], ['foo', 'bar']),
        ({'a': 1, 'b': 2}, [1, 2]),
        ({'a': [1, 2], 'b': [3, 4]}, [1, 2, 3, 4]),
        ({'a': [[1, 2]], 'b': [[3, 4]]}, [1, 2, 3, 4]),
        ({'a': [[1, 2]], 'b': [3, 4]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [[[3], [4]]]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [[3, 4]]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [3, 4]}, [1, 2, 3, 4]),
        ({'a': [[[1], [2]]], 'b': [3, [4]]}, [1, 2, 3, 4]),
        ({'a': {'1': 1}, 'b': 2}, [1, 2]),
        ({'a': {'1': [1]}, 'b': 2}, [1, 2]),
        ({'a': {'1': [1]}, 'b': [2]}, [1, 2]),
    ]      ,   )
def      a_ (      _A      ,   _A  )			->			Optional[int]:







				"""simple docstring"""
				snake_case__									=     NestedDataStructure(__lowerCAmelCase  ).flatten()
				assert output == expected_output
def      a_ (      )			->			List[Any]:







				"""simple docstring"""
				snake_case__									=     A(x=1      ,   y='foobar'  )
				snake_case__									=     {'x': 1, 'y': 'foobar'}
				assert asdict(__lowerCAmelCase  ) == expected_output

				snake_case__									=     {'a': {'b': A(x=10      ,   y='foo'  )}, 'c': [A(x=20      ,   y='bar'  )]}
				snake_case__									=     {'a': {'b': {'x': 10, 'y': 'foo'}}, 'c': [{'x': 20, 'y': 'bar'}]}
				assert asdict(__lowerCAmelCase  ) == expected_output

				with pytest.raises(__lowerCAmelCase  ):
								asdict([1, A(x=10      ,   y='foo'  )]  )
def      a_ (      _A  )			->			Optional[int]:







				"""simple docstring"""
				return text.split()
def      a_ (      _A  )			->			Union[str, Any]:







				"""simple docstring"""
				yield (time.time(), content)
				time.sleep(2  )
				yield (time.time(), content)


def      a_ (      )			->			List[Any]:







				"""simple docstring"""
				with Pool(2  ) as pool:
								snake_case__									=     list(iflatmap_unordered(__lowerCAmelCase      ,   _split_text      ,   kwargs_iterable=[{'text': 'hello there'}] * 10  )  )
								assert out.count('hello'  ) == 10
								assert out.count('there'  ) == 10
								assert len(__lowerCAmelCase  ) == 20

				# check multiprocess from pathos (uses dill for pickling)
				with multiprocess.Pool(2  ) as pool:
								snake_case__									=     list(iflatmap_unordered(__lowerCAmelCase      ,   _split_text      ,   kwargs_iterable=[{'text': 'hello there'}] * 10  )  )
								assert out.count('hello'  ) == 10
								assert out.count('there'  ) == 10
								assert len(__lowerCAmelCase  ) == 20

				# check that we get items as fast as possible
				with Pool(2  ) as pool:
								snake_case__									=     []
								for yield_time, content in iflatmap_unordered(
								    __lowerCAmelCase      ,   _aseconds_generator_of_aitems_with_timing      ,   kwargs_iterable=[{'content': 'a'}, {'content': 'b'}]  ):
												assert yield_time < time.time() + 0.1, "we should each item directly after it was yielded"
												out.append(__lowerCAmelCase  )
								assert out.count('a'  ) == 2
								assert out.count('b'  ) == 2
								assert len(__lowerCAmelCase  ) == 4












import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class   __SCREAMING_SNAKE_CASE(	a_    ,  a_    ,  a_    ,  unittest.TestCase	):
							_UpperCAmelCase     =       StableUnCLIPImgaImgPipeline
							_UpperCAmelCase     =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS
							_UpperCAmelCase     =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							_UpperCAmelCase     =       frozenset(
							    []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							_UpperCAmelCase     =       frozenset([]	)
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Union[str, Any]:
											snake_case__									=     32
											snake_case__									=     embedder_hidden_size

											# image encoding components

											snake_case__									=     CLIPImageProcessor(crop_size=32       ,	size=32						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPVisionModelWithProjection(
											    CLIPVisionConfig(
											        hidden_size=UpperCamelCase       ,	projection_dim=UpperCamelCase       ,	num_hidden_layers=5       ,	num_attention_heads=4       ,	image_size=32       ,	intermediate_size=37       ,	patch_size=1       ,	)						)

											# regular denoising components

											torch.manual_seed(0						)
											snake_case__									=     StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase						)
											snake_case__									=     DDPMScheduler(beta_schedule='squaredcos_cap_v2'						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPTextModel(
											    CLIPTextConfig(
											        bos_token_id=0       ,	eos_token_id=2       ,	hidden_size=UpperCamelCase       ,	projection_dim=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       ,	)						)

											torch.manual_seed(0						)
											snake_case__									=     UNetaDConditionModel(
											    sample_size=32       ,	in_channels=4       ,	out_channels=4       ,	down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')       ,	up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')       ,	block_out_channels=(32, 64)       ,	attention_head_dim=(2, 4)       ,	class_embed_type='projection'       ,	projection_class_embeddings_input_dim=embedder_projection_dim * 2       ,	cross_attention_dim=UpperCamelCase       ,	layers_per_block=1       ,	upcast_attention=UpperCamelCase       ,	use_linear_projection=UpperCamelCase       ,	)

											torch.manual_seed(0						)
											snake_case__									=     DDIMScheduler(
											    beta_schedule='scaled_linear'       ,	beta_start=0.00_085       ,	beta_end=0.012       ,	prediction_type='v_prediction'       ,	set_alpha_to_one=UpperCamelCase       ,	steps_offset=1       ,	)

											torch.manual_seed(0						)
											snake_case__									=     AutoencoderKL()

											snake_case__									=     {
											    # image encoding components
											    'feature_extractor': feature_extractor,
											    'image_encoder': image_encoder.eval(),
											    # image noising components
											    'image_normalizer': image_normalizer.eval(),
											    'image_noising_scheduler': image_noising_scheduler,
											    # regular denoising components
											    'tokenizer': tokenizer,
											    'text_encoder': text_encoder.eval(),
											    'unet': unet.eval(),
											    'scheduler': scheduler,
											    'vae': vae.eval(),
											}

											return components
							def lowerCAmelCase_ (     self:      str       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      Tuple=0       ,	UpperCamelCase:      Union[str, Any]=True						)		->		Any:
											if str(UpperCamelCase						).startswith('mps'						):
															snake_case__									=     torch.manual_seed(UpperCamelCase						)
											else:
															snake_case__									=     torch.Generator(device=UpperCamelCase						).manual_seed(UpperCamelCase						)

											snake_case__									=     floats_tensor((1, 3, 32, 32)       ,	rng=random.Random(UpperCamelCase						)						).to(UpperCamelCase						)

											if pil_image:
															snake_case__									=     input_image * 0.5 + 0.5
															snake_case__									=     input_image.clamp(0       ,	1						)
															snake_case__									=     input_image.cpu().permute(0       ,	2       ,	3       ,	1						).float().numpy()
															snake_case__									=     DiffusionPipeline.numpy_to_pil(UpperCamelCase						)[0]

											return {
											    "prompt": "An anime racoon running a marathon",
											    "image": input_image,
											    "generator": generator,
											    "num_inference_steps": 2,
											    "output_type": "np",
											}
							@skip_mps
							def lowerCAmelCase_ (     self:      Dict						)		->		Optional[Any]:
											snake_case__									=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											snake_case__									=     self.get_dummy_components()
											snake_case__									=     StableUnCLIPImgaImgPipeline(**UpperCamelCase						)
											snake_case__									=     sd_pipe.to(UpperCamelCase						)
											sd_pipe.set_progress_bar_config(disable=UpperCamelCase						)

											snake_case__									=     self.get_dummy_inputs(UpperCamelCase						)
											inputs.update({'image_embeds': None}						)
											snake_case__									=     sd_pipe(**UpperCamelCase						).images
											snake_case__									=     image[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											snake_case__									=     np.array([0.3_872, 0.7_224, 0.5_601, 0.4_741, 0.6_872, 0.5_814, 0.4_636, 0.3_867, 0.5_078]						)

											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Union[str, Any]:
											snake_case__									=     torch_device in ['cpu', 'mps']

											self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase						)
							def lowerCAmelCase_ (     self:      List[Any]						)		->		int:
											snake_case__									=     torch_device in ['cpu', 'mps']

											self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase						)


							@unittest.skipIf(
							    torch_device != 'cuda' or not is_xformers_available()       ,	reason='XFormers attention is only available with CUDA and `xformers` installed'       ,	)
							def lowerCAmelCase_ (     self:      str						)		->		Optional[int]:
											self._test_xformers_attention_forwardGenerator_pass(test_max_difference=UpperCamelCase						)


@slow
@require_torch_gpu
class   __SCREAMING_SNAKE_CASE(	unittest.TestCase	):
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Optional[int]:
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Dict:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											snake_case__									=     load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy'						)

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-l-img2img'       ,	torch_dtype=torch.floataa						)
											pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     torch.Generator(device='cpu'						).manual_seed(0						)
											snake_case__									=     pipe(UpperCamelCase       ,	'anime turle'       ,	generator=UpperCamelCase       ,	output_type='np'						)

											snake_case__									=     output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Dict:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											snake_case__									=     load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy'						)

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-h-img2img'       ,	torch_dtype=torch.floataa						)
											pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     torch.Generator(device='cpu'						).manual_seed(0						)
											snake_case__									=     pipe(UpperCamelCase       ,	'anime turle'       ,	generator=UpperCamelCase       ,	output_type='np'						)

											snake_case__									=     output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase       ,	UpperCamelCase						)


							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		str:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											torch.cuda.empty_cache()
											torch.cuda.reset_max_memory_allocated()
											torch.cuda.reset_peak_memory_stats()

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-h-img2img'       ,	torch_dtype=torch.floataa						)
											snake_case__									=     pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     pipe(
											    UpperCamelCase       ,	'anime turtle'       ,	num_inference_steps=2       ,	output_type='np'       ,	)

											snake_case__									=     torch.cuda.max_memory_allocated()
											# make sure that less than 7 GB is allocated
											assert mem_bytes < 7 * 10**9




