



import os
import tempfile
import unittest

import numpy as np

from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax, slow


if is_flax_available():
							import jax
							import jax.numpy as jnp
							from flax.jax_utils import replicate
							from flax.training.common_utils import shard

							from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline
@require_flax
class 				_snake_case			(					unittest.TestCase):




				def 							A__      (						self					:						Optional[Any]						):
							with tempfile.TemporaryDirectory() as tmpdirname:
										# pipeline has Flax weights
										lowercase__					  =				FlaxDiffusionPipeline.from_pretrained(
										    "hf-internal-testing/tiny-stable-diffusion-pipe",					safety_checker=__lowercase,					cache_dir=__lowercase						)

										lowercase__					  =				[t[-1] for t in os.walk(os.path.join(__lowercase,					os.listdir(__lowercase						)[0],					"snapshots"						)						)]
										lowercase__					  =				[item for sublist in all_root_files for item in sublist]

										# None of the downloaded files should be a PyTorch file even if we have some here:
										# https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
										assert not any(f.endswith(".bin"						) for f in files						)
@slow
@require_flax
class 				_snake_case			(					unittest.TestCase):




				def 							A__      (						self					:						Any						):
							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "hf-internal-testing/tiny-stable-diffusion-pipe",					safety_checker=__lowercase						)

							lowercase__					  =				(
							    "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
							    " field, close up, split lighting, cinematic"
							)

							lowercase__					  =				jax.random.PRNGKey(0						)
							lowercase__					  =				4

							lowercase__					  =				jax.device_count()
							lowercase__					  =				num_samples * [prompt]
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)

							# shard inputs and rng
							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				jax.random.split(__lowercase,					__lowercase						)
							lowercase__					  =				shard(__lowercase						)

							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images

							assert images.shape == (num_samples, 1, 64, 64, 3)
							if jax.device_count() == 8:
										assert np.abs(np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa						).sum() - 4.1514745						) < 1e-3
										assert np.abs(np.abs(__lowercase,					dtype=np.floataa						).sum() - 49947.875						) < 5e-1

							lowercase__					  =				pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]						)						)						)
							assert len(__lowercase						) == num_samples




				def 							A__      (						self					:						Union[str, Any]						):
							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "CompVis/stable-diffusion-v1-4",					revision="flax",					safety_checker=__lowercase						)

							lowercase__					  =				(
							    "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
							    " field, close up, split lighting, cinematic"
							)

							lowercase__					  =				jax.random.PRNGKey(0						)
							lowercase__					  =				50

							lowercase__					  =				jax.device_count()
							lowercase__					  =				num_samples * [prompt]
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)

							# shard inputs and rng
							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				jax.random.split(__lowercase,					__lowercase						)
							lowercase__					  =				shard(__lowercase						)

							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images

							assert images.shape == (num_samples, 1, 512, 512, 3)
							if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa						).sum() - 0.05652401)						) < 1e-3
										assert np.abs((np.abs(__lowercase,					dtype=np.floataa						).sum() - 2383808.2)						) < 5e-1




				def 							A__      (						self					:						int						):
							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=__lowercase						)

							lowercase__					  =				(
							    "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
							    " field, close up, split lighting, cinematic"
							)

							lowercase__					  =				jax.random.PRNGKey(0						)
							lowercase__					  =				50

							lowercase__					  =				jax.device_count()
							lowercase__					  =				num_samples * [prompt]
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)

							# shard inputs and rng
							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				jax.random.split(__lowercase,					__lowercase						)
							lowercase__					  =				shard(__lowercase						)

							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images

							assert images.shape == (num_samples, 1, 512, 512, 3)
							if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa						).sum() - 0.04003906)						) < 1e-3
										assert np.abs((np.abs(__lowercase,					dtype=np.floataa						).sum() - 2373516.75)						) < 5e-1




				def 							A__      (						self					:						Dict						):
							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa						)

							lowercase__					  =				(
							    "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
							    " field, close up, split lighting, cinematic"
							)

							lowercase__					  =				jax.random.PRNGKey(0						)
							lowercase__					  =				50

							lowercase__					  =				jax.device_count()
							lowercase__					  =				num_samples * [prompt]
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)

							# shard inputs and rng
							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				jax.random.split(__lowercase,					__lowercase						)
							lowercase__					  =				shard(__lowercase						)

							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images

							assert images.shape == (num_samples, 1, 512, 512, 3)
							if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa						).sum() - 0.04003906)						) < 1e-3
										assert np.abs((np.abs(__lowercase,					dtype=np.floataa						).sum() - 2373516.75)						) < 5e-1




				def 							A__      (						self					:						Union[str, Any]						):
							lowercase__					  =				FlaxDDIMScheduler(
							    beta_start=0.00085,					beta_end=0.012,					beta_schedule="scaled_linear",					set_alpha_to_one=__lowercase,					steps_offset=1,					)

							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					scheduler=__lowercase,					safety_checker=__lowercase,					)
							lowercase__					  =				scheduler.create_state()

							lowercase__					  =				scheduler_state

							lowercase__					  =				(
							    "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
							    " field, close up, split lighting, cinematic"
							)

							lowercase__					  =				jax.random.PRNGKey(0						)
							lowercase__					  =				50

							lowercase__					  =				jax.device_count()
							lowercase__					  =				num_samples * [prompt]
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)

							# shard inputs and rng
							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				jax.random.split(__lowercase,					__lowercase						)
							lowercase__					  =				shard(__lowercase						)

							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images

							assert images.shape == (num_samples, 1, 512, 512, 3)
							if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:],					dtype=np.floataa						).sum() - 0.045043945)						) < 1e-3
										assert np.abs((np.abs(__lowercase,					dtype=np.floataa						).sum() - 2347693.5)						) < 5e-1




				def 							A__      (						self					:						Dict						):
							lowercase__					  =				(
							    "A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
							    " field, close up, split lighting, cinematic"
							)

							lowercase__					  =				jax.device_count()
							lowercase__					  =				num_samples * [prompt]
							lowercase__					  =				jax.random.split(jax.random.PRNGKey(0						),					__lowercase						)

							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=__lowercase,					)

							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)
							lowercase__					  =				shard(__lowercase						)
							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images
							assert images.shape == (num_samples, 1, 512, 512, 3)
							lowercase__					  =				images[2, 0, 256, 10:17, 1]

							# With memory efficient attention
							lowercase__  ,       lowercase__					  =				FlaxStableDiffusionPipeline.from_pretrained(
							    "CompVis/stable-diffusion-v1-4",					revision="bf16",					dtype=jnp.bfloataa,					safety_checker=__lowercase,					use_memory_efficient_attention=__lowercase,					)

							lowercase__					  =				replicate(__lowercase						)
							lowercase__					  =				pipeline.prepare_inputs(__lowercase						)
							lowercase__					  =				shard(__lowercase						)
							lowercase__					  =				pipeline(__lowercase,					__lowercase,					__lowercase,					jit=__lowercase						).images
							assert images_eff.shape == (num_samples, 1, 512, 512, 3)
							lowercase__					  =				images[2, 0, 256, 10:17, 1]

							# I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
							# over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
							assert abs(slice_eff - slice						).max() < 1e-2









import unittest

import numpy as np
import requests

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

							from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
							lowercase_								=     False

if is_vision_available():
							from PIL import Image

							from transformers import PixaStructImageProcessor
class 				_snake_case			(					unittest.TestCase):




				def __init__(						self					:						List[Any],					__lowercase					:						int,					__lowercase					:						Optional[int]=7,					__lowercase					:						List[str]=3,					__lowercase					:						Tuple=18,					__lowercase					:						List[Any]=30,					__lowercase					:						Tuple=400,					__lowercase					:						Any=None,					__lowercase					:						Optional[int]=True,					__lowercase					:						List[str]=True,					__lowercase					:						Union[str, Any]=None,					):
							lowercase__					  =				size if size is not None else {"height": 20, "width": 20}
							lowercase__					  =				parent
							lowercase__					  =				batch_size
							lowercase__					  =				num_channels
							lowercase__					  =				image_size
							lowercase__					  =				min_resolution
							lowercase__					  =				max_resolution
							lowercase__					  =				size
							lowercase__					  =				do_normalize
							lowercase__					  =				do_convert_rgb
							lowercase__					  =				[512, 1024, 2048, 4096]
							lowercase__					  =				patch_size if patch_size is not None else {"height": 16, "width": 16}




				def 							A__      (						self					:						List[str]						):
							return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}




				def 							A__      (						self					:						Any						):
							lowercase__					  =				"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg"
							lowercase__					  =				Image.open(requests.get(__lowercase,					stream=__lowercase						).raw						).convert("RGB"						)
							return raw_image
@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,	reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,	)
@require_torch
@require_vision
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Any     		=PixaStructImageProcessor if is_vision_available() else None




				def 							A__      (						self					:						Any						):
							lowercase__					  =				PixaStructImageProcessingTester(self						)




				@property
				def 							A__      (						self					:						Union[str, Any]						):
							return self.image_processor_tester.prepare_image_processor_dict()




				def 							A__      (						self					:						Optional[Any]						):
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							self.assertTrue(hasattr(__lowercase,					"do_normalize"						)						)
							self.assertTrue(hasattr(__lowercase,					"do_convert_rgb"						)						)




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				self.image_processor_tester.prepare_dummy_image()

							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							lowercase__					  =				2048

							lowercase__					  =				image_processor(__lowercase,					return_tensors="pt",					max_patches=__lowercase						)
							self.assertTrue(torch.allclose(inputs.flattened_patches.mean(),					torch.tensor(0.0606						),					atol=1e-3,					rtol=1e-3						)						)




				def 							A__      (						self					:						Union[str, Any]						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						int						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							lowercase__					  =				True

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										with self.assertRaises(__lowercase						):
													lowercase__					  =				image_processor(
													    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches

										lowercase__					  =				"Hello"

										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase,					header_text=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase,					header_text=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						Tuple						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random numpy tensors
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase,					numpify=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					np.ndarray						)

							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						Any						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PyTorch tensors
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase,					torchify=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					torch.Tensor						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)
@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,	reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,	)
@require_torch
@require_vision
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Optional[int]     		=PixaStructImageProcessor if is_vision_available() else None




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				PixaStructImageProcessingTester(self,					num_channels=4						)
							lowercase__					  =				3




				@property
				def 							A__      (						self					:						Union[str, Any]						):
							return self.image_processor_tester.prepare_image_processor_dict()




				def 							A__      (						self					:						Dict						):
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							self.assertTrue(hasattr(__lowercase,					"do_normalize"						)						)
							self.assertTrue(hasattr(__lowercase,					"do_convert_rgb"						)						)




				def 							A__      (						self					:						Union[str, Any]						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * (self.image_processor_tester.num_channels - 1)
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




