




import unittest

import numpy as np
from datasets import load_dataset

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

if is_vision_available():
				from PIL import Image

				from transformers import BeitImageProcessor



class       a_       (     unittest.TestCase     ):





	def __init__(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE=7      ,     SCREAMING_SNAKE_CASE=3      ,     SCREAMING_SNAKE_CASE=18      ,     SCREAMING_SNAKE_CASE=30      ,     SCREAMING_SNAKE_CASE=400      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=None      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=None      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]      ,     SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]      ,     SCREAMING_SNAKE_CASE=False      ,     )  ->					List[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						size if size is not None else {'height': 20, 'width': 20}
				SCREAMING_SNAKE_CASE_								=						crop_size if crop_size is not None else {'height': 18, 'width': 18}
				SCREAMING_SNAKE_CASE_								=						parent
				SCREAMING_SNAKE_CASE_								=						batch_size
				SCREAMING_SNAKE_CASE_								=						num_channels
				SCREAMING_SNAKE_CASE_								=						image_size
				SCREAMING_SNAKE_CASE_								=						min_resolution
				SCREAMING_SNAKE_CASE_								=						max_resolution
				SCREAMING_SNAKE_CASE_								=						do_resize
				SCREAMING_SNAKE_CASE_								=						size
				SCREAMING_SNAKE_CASE_								=						do_center_crop
				SCREAMING_SNAKE_CASE_								=						crop_size
				SCREAMING_SNAKE_CASE_								=						do_normalize
				SCREAMING_SNAKE_CASE_								=						image_mean
				SCREAMING_SNAKE_CASE_								=						image_std
				SCREAMING_SNAKE_CASE_								=						do_reduce_labels





	def 						A_(							self      )  ->					Tuple:




				"""simple docstring"""



				return {
				    "do_resize": self.do_resize,
				    "size": self.size,
				    "do_center_crop": self.do_center_crop,
				    "crop_size": self.crop_size,
				    "do_normalize": self.do_normalize,
				    "image_mean": self.image_mean,
				    "image_std": self.image_std,
				    "do_reduce_labels": self.do_reduce_labels,
				}




def lowercase    (  )			->							List[str]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						load_dataset('hf-internal-testing/fixtures_ade20k'       ,    split='test' )

			SCREAMING_SNAKE_CASE_								=						Image.open(dataset[0]['file'] )
			SCREAMING_SNAKE_CASE_								=						Image.open(dataset[1]['file'] )

			return image, map

def lowercase    (  )			->							Tuple:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						load_dataset('hf-internal-testing/fixtures_ade20k'       ,    split='test' )

			SCREAMING_SNAKE_CASE_								=						Image.open(ds[0]['file'] )
			SCREAMING_SNAKE_CASE_								=						Image.open(ds[1]['file'] )
			SCREAMING_SNAKE_CASE_								=						Image.open(ds[2]['file'] )
			SCREAMING_SNAKE_CASE_								=						Image.open(ds[3]['file'] )

			return [imagea, imagea], [mapa, mapa]



@require_torch
@require_vision
class       a_       (     SCREAMING_SNAKE_CASE__  ,    unittest.TestCase     ):
	A    							= BeitImageProcessor if is_vision_available() else None





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						BeitImageProcessingTester(self      )





	@property
	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				return self.image_processor_tester.prepare_image_processor_dict()





	def 						A_(							self      )  ->					Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class(**self.image_processor_dict      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'do_resize'      )      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'size'      )      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'do_center_crop'      )      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'center_crop'      )      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'do_normalize'      )      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'image_mean'      )      )
				self.assertTrue(hasattr(SCREAMING_SNAKE_CASE      ,     'image_std'      )      )





	def 						A_(							self      )  ->					int:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class.from_dict(self.image_processor_dict      )
				self.assertEqual(image_processor.size      ,     {'height': 20, 'width': 20}      )
				self.assertEqual(image_processor.crop_size      ,     {'height': 18, 'width': 18}      )
				self.assertEqual(image_processor.do_reduce_labels      ,     SCREAMING_SNAKE_CASE      )

				SCREAMING_SNAKE_CASE_								=						self.image_processing_class.from_dict(
				    self.image_processor_dict      ,     size=42      ,     crop_size=84      ,     reduce_labels=SCREAMING_SNAKE_CASE      )
				self.assertEqual(image_processor.size      ,     {'height': 42, 'width': 42}      )
				self.assertEqual(image_processor.crop_size      ,     {'height': 84, 'width': 84}      )
				self.assertEqual(image_processor.do_reduce_labels      ,     SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					Tuple:




				"""simple docstring"""



				pass





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class(**self.image_processor_dict      )
				# create random PIL images
				SCREAMING_SNAKE_CASE_								=						prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=SCREAMING_SNAKE_CASE      )
				for image in image_inputs:
							self.assertIsInstance(SCREAMING_SNAKE_CASE      ,     Image.Image      )

				# Test not batched input
				SCREAMING_SNAKE_CASE_								=						image_processing(image_inputs[0]      ,     return_tensors='pt'      ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,     (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )

				# Test batched
				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,     (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )





	def 						A_(							self      )  ->					Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class(**self.image_processor_dict      )
				# create random numpy tensors
				SCREAMING_SNAKE_CASE_								=						prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=SCREAMING_SNAKE_CASE      ,     numpify=SCREAMING_SNAKE_CASE      )
				for image in image_inputs:
							self.assertIsInstance(SCREAMING_SNAKE_CASE      ,     np.ndarray      )

				# Test not batched input
				SCREAMING_SNAKE_CASE_								=						image_processing(image_inputs[0]      ,     return_tensors='pt'      ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,     (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )

				# Test batched
				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,     (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )





	def 						A_(							self      )  ->					Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class(**self.image_processor_dict      )
				# create random PyTorch tensors
				SCREAMING_SNAKE_CASE_								=						prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=SCREAMING_SNAKE_CASE      ,     torchify=SCREAMING_SNAKE_CASE      )
				for image in image_inputs:
							self.assertIsInstance(SCREAMING_SNAKE_CASE      ,     torch.Tensor      )

				# Test not batched input
				SCREAMING_SNAKE_CASE_								=						image_processing(image_inputs[0]      ,     return_tensors='pt'      ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,     (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )

				# Test batched
				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      ).pixel_values
				self.assertEqual(
				    encoded_images.shape      ,     (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class(**self.image_processor_dict      )
				# create random PyTorch tensors
				SCREAMING_SNAKE_CASE_								=						prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=SCREAMING_SNAKE_CASE      ,     torchify=SCREAMING_SNAKE_CASE      )
				SCREAMING_SNAKE_CASE_								=						[]
				for image in image_inputs:
							self.assertIsInstance(SCREAMING_SNAKE_CASE      ,     torch.Tensor      )
							maps.append(torch.zeros(image.shape[-2:]      ).long()      )

				# Test not batched input
				SCREAMING_SNAKE_CASE_								=						image_processing(image_inputs[0]      ,     maps[0]      ,     return_tensors='pt'      )
				self.assertEqual(
				    encoding['pixel_values'].shape      ,     (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(
				    encoding['labels'].shape      ,     (
				        1,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(encoding['labels'].dtype      ,     torch.long      )
				self.assertTrue(encoding['labels'].min().item() >= 0      )
				self.assertTrue(encoding['labels'].max().item() <= 255      )

				# Test batched
				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )
				self.assertEqual(
				    encoding['pixel_values'].shape      ,     (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(
				    encoding['labels'].shape      ,     (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(encoding['labels'].dtype      ,     torch.long      )
				self.assertTrue(encoding['labels'].min().item() >= 0      )
				self.assertTrue(encoding['labels'].max().item() <= 255      )

				# Test not batched input (PIL images)
				SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						prepare_semantic_single_inputs()

				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )
				self.assertEqual(
				    encoding['pixel_values'].shape      ,     (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(
				    encoding['labels'].shape      ,     (
				        1,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(encoding['labels'].dtype      ,     torch.long      )
				self.assertTrue(encoding['labels'].min().item() >= 0      )
				self.assertTrue(encoding['labels'].max().item() <= 255      )

				# Test batched input (PIL images)
				SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						prepare_semantic_batch_inputs()

				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )
				self.assertEqual(
				    encoding['pixel_values'].shape      ,     (
				        2,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(
				    encoding['labels'].shape      ,     (
				        2,
				        self.image_processor_tester.crop_size['height'],
				        self.image_processor_tester.crop_size['width'],
				    )      ,     )
				self.assertEqual(encoding['labels'].dtype      ,     torch.long      )
				self.assertTrue(encoding['labels'].min().item() >= 0      )
				self.assertTrue(encoding['labels'].max().item() <= 255      )





	def 						A_(							self      )  ->					List[str]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.image_processing_class(**self.image_processor_dict      )

				# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
				SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						prepare_semantic_single_inputs()
				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )
				self.assertTrue(encoding['labels'].min().item() >= 0      )
				self.assertTrue(encoding['labels'].max().item() <= 150      )

				SCREAMING_SNAKE_CASE_								=						True
				SCREAMING_SNAKE_CASE_								=						image_processing(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )
				self.assertTrue(encoding['labels'].min().item() >= 0      )
				self.assertTrue(encoding['labels'].max().item() <= 255      )






import unittest

from diffusers import FlaxAutoencoderKL
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax

from .test_modeling_common_flax import FlaxModelTesterMixin


if is_flax_available():
				import jax



@require_flax
class       a_       (     SCREAMING_SNAKE_CASE__  ,    unittest.TestCase     ):
	A    							= FlaxAutoencoderKL





	@property
	def 						A_(							self      )  ->					Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						4
				SCREAMING_SNAKE_CASE_								=						3
				SCREAMING_SNAKE_CASE_								=						(32, 32)

				SCREAMING_SNAKE_CASE_								=						jax.random.PRNGKey(0      )
				SCREAMING_SNAKE_CASE_								=						jax.random.uniform(SCREAMING_SNAKE_CASE      ,     ((batch_size, num_channels) + sizes)      )

				return {"sample": image, "prng_key": prng_key}





	def 						A_(							self      )  ->					Tuple:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						{
				    'block_out_channels': [32, 64],
				    'in_channels': 3,
				    'out_channels': 3,
				    'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
				    'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
				    'latent_channels': 4,
				}
				SCREAMING_SNAKE_CASE_								=						self.dummy_input
				return init_dict, inputs_dict
