


'''simple docstring'''



import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class 	UpperCamelCase__(       unittest.TestCase	):




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

										"""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





				def 					a__(		self      :			Tuple				)->					List[Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     self.dummy_uncond_unet
										UpperCAmelCase					    =     PNDMScheduler()

										UpperCAmelCase					    =     PNDMPipeline(unet=a_				,   scheduler=a_				)
										pndm.to(a_				)
										pndm.set_progress_bar_config(disable=a_				)

										UpperCAmelCase					    =     torch.manual_seed(0				)
										UpperCAmelCase					    =     pndm(generator=a_				,   num_inference_steps=20				,   output_type='''numpy'''				).images

										UpperCAmelCase					    =     torch.manual_seed(0				)
										UpperCAmelCase					    =     pndm(generator=a_				,   num_inference_steps=20				,   output_type='''numpy'''				,   return_dict=a_				)[0]

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

										assert image.shape == (1, 32, 32, 3)
										UpperCAmelCase					    =     np.array([1.0, 1.0, 0.0, 1.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 	UpperCamelCase__(       unittest.TestCase	):




				def 					a__(		self      :			Tuple				)->					int:

										"""simple docstring"""




										UpperCAmelCase					    =     '''google/ddpm-cifar10-32'''

										UpperCAmelCase					    =     UNetaDModel.from_pretrained(a_				)
										UpperCAmelCase					    =     PNDMScheduler()

										UpperCAmelCase					    =     PNDMPipeline(unet=a_				,   scheduler=a_				)
										pndm.to(a_				)
										pndm.set_progress_bar_config(disable=a_				)
										UpperCAmelCase					    =     torch.manual_seed(0				)
										UpperCAmelCase					    =     pndm(generator=a_				,   output_type='''numpy'''				).images

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

										assert image.shape == (1, 32, 32, 3)
										UpperCAmelCase					    =     np.array([0.1564, 0.14645, 0.1406, 0.14715, 0.12425, 0.14045, 0.13115, 0.12175, 0.125]				)

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






'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowercase      :      List[Any]            =					{
    """configuration_x_clip""": [
        """XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XCLIPConfig""",
        """XCLIPTextConfig""",
        """XCLIPVisionConfig""",
    ],
    """processing_x_clip""": ["""XCLIPProcessor"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowercase      :      List[str]            =					[
	    """XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """XCLIPModel""",
	    """XCLIPPreTrainedModel""",
	    """XCLIPTextModel""",
	    """XCLIPVisionModel""",
	]

if TYPE_CHECKING:
	from .configuration_x_clip import (
	    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    XCLIPConfig,
	    XCLIPTextConfig,
	    XCLIPVisionConfig,
	)
	from .processing_x_clip import XCLIPProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_x_clip import (
		    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XCLIPModel,
		    XCLIPPreTrainedModel,
		    XCLIPTextModel,
		    XCLIPVisionModel,
		)

else:
	import sys

	_lowercase      :      List[Any]            =					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





