




import shutil
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
				from PIL import Image

				from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
				import torch

if is_tf_available():
				import tensorflow as tf



@require_vision
@require_torchvision
class       a_       (     unittest.TestCase     ):





	def 						A_(							self      )  ->					str:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						tempfile.mkdtemp()
				SCREAMING_SNAKE_CASE_								=						SamImageProcessor()
				SCREAMING_SNAKE_CASE_								=						SamProcessor(SCREAMING_SNAKE_CASE      )
				processor.save_pretrained(self.tmpdirname      )





	def 						A_(							self      ,     **SCREAMING_SNAKE_CASE      )  ->					int:




				"""simple docstring"""



				return AutoProcessor.from_pretrained(self.tmpdirname      ,     **SCREAMING_SNAKE_CASE      ).image_processor





	def 						A_(							self      )  ->					str:




				"""simple docstring"""



				shutil.rmtree(self.tmpdirname      )





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						[np.random.randint(255      ,     size=(3, 30, 400)      ,     dtype=np.uinta      )]

				SCREAMING_SNAKE_CASE_								=						[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE      ,     0      ,     -1      )      ) for x in image_inputs]

				return image_inputs





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=self.get_image_processor()      )
				processor.save_pretrained(self.tmpdirname      )

				SCREAMING_SNAKE_CASE_								=						self.get_image_processor(do_normalize=SCREAMING_SNAKE_CASE      ,     padding_value=1.0      )

				SCREAMING_SNAKE_CASE_								=						SamProcessor.from_pretrained(self.tmpdirname      ,     do_normalize=SCREAMING_SNAKE_CASE      ,     padding_value=1.0      )

				self.assertEqual(processor.image_processor.to_json_string()      ,     image_processor_add_kwargs.to_json_string()      )
				self.assertIsInstance(processor.image_processor      ,     SCREAMING_SNAKE_CASE      )





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_image_processor()

				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=SCREAMING_SNAKE_CASE      )

				SCREAMING_SNAKE_CASE_								=						self.prepare_image_inputs()

				SCREAMING_SNAKE_CASE_								=						image_processor(SCREAMING_SNAKE_CASE      ,     return_tensors='np'      )
				SCREAMING_SNAKE_CASE_								=						processor(images=SCREAMING_SNAKE_CASE      ,     return_tensors='np'      )

				input_feat_extract.pop('original_sizes'      )  # pop original_sizes as it is popped in the processor
				input_feat_extract.pop('reshaped_input_sizes'      )  # pop original_sizes as it is popped in the processor

				for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()      ,     input_processor[key].sum()      ,     delta=1e-2      )





	@require_torch
	def 						A_(							self      )  ->					Union[str, Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_image_processor()

				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=SCREAMING_SNAKE_CASE      )
				SCREAMING_SNAKE_CASE_								=						[torch.ones((1, 3, 5, 5)      )]

				SCREAMING_SNAKE_CASE_								=						[[1764, 2646]]

				SCREAMING_SNAKE_CASE_								=						[[683, 1024]]
				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )
				self.assertEqual(masks[0].shape      ,     (1, 3, 1764, 2646)      )

				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(
				    SCREAMING_SNAKE_CASE      ,     torch.tensor(SCREAMING_SNAKE_CASE      )      ,     torch.tensor(SCREAMING_SNAKE_CASE      )      )
				self.assertEqual(masks[0].shape      ,     (1, 3, 1764, 2646)      )

				# should also work with np
				SCREAMING_SNAKE_CASE_								=						[np.ones((1, 3, 5, 5)      )]
				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(SCREAMING_SNAKE_CASE      ,     np.array(SCREAMING_SNAKE_CASE      )      ,     np.array(SCREAMING_SNAKE_CASE      )      )

				self.assertEqual(masks[0].shape      ,     (1, 3, 1764, 2646)      )

				SCREAMING_SNAKE_CASE_								=						[[1, 0], [0, 1]]
				with self.assertRaises(SCREAMING_SNAKE_CASE      ):
							SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(SCREAMING_SNAKE_CASE      ,     np.array(SCREAMING_SNAKE_CASE      )      ,     np.array(SCREAMING_SNAKE_CASE      )      )




@require_vision
@require_tf
class       a_       (     unittest.TestCase     ):





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						tempfile.mkdtemp()
				SCREAMING_SNAKE_CASE_								=						SamImageProcessor()
				SCREAMING_SNAKE_CASE_								=						SamProcessor(SCREAMING_SNAKE_CASE      )
				processor.save_pretrained(self.tmpdirname      )





	def 						A_(							self      ,     **SCREAMING_SNAKE_CASE      )  ->					Any:




				"""simple docstring"""



				return AutoProcessor.from_pretrained(self.tmpdirname      ,     **SCREAMING_SNAKE_CASE      ).image_processor





	def 						A_(							self      )  ->					Tuple:




				"""simple docstring"""



				shutil.rmtree(self.tmpdirname      )





	def 						A_(							self      )  ->					Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						[np.random.randint(255      ,     size=(3, 30, 400)      ,     dtype=np.uinta      )]

				SCREAMING_SNAKE_CASE_								=						[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE      ,     0      ,     -1      )      ) for x in image_inputs]

				return image_inputs





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=self.get_image_processor()      )
				processor.save_pretrained(self.tmpdirname      )

				SCREAMING_SNAKE_CASE_								=						self.get_image_processor(do_normalize=SCREAMING_SNAKE_CASE      ,     padding_value=1.0      )

				SCREAMING_SNAKE_CASE_								=						SamProcessor.from_pretrained(self.tmpdirname      ,     do_normalize=SCREAMING_SNAKE_CASE      ,     padding_value=1.0      )

				self.assertEqual(processor.image_processor.to_json_string()      ,     image_processor_add_kwargs.to_json_string()      )
				self.assertIsInstance(processor.image_processor      ,     SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_image_processor()

				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=SCREAMING_SNAKE_CASE      )

				SCREAMING_SNAKE_CASE_								=						self.prepare_image_inputs()

				SCREAMING_SNAKE_CASE_								=						image_processor(SCREAMING_SNAKE_CASE      ,     return_tensors='np'      )
				SCREAMING_SNAKE_CASE_								=						processor(images=SCREAMING_SNAKE_CASE      ,     return_tensors='np'      )

				input_feat_extract.pop('original_sizes'      )  # pop original_sizes as it is popped in the processor
				input_feat_extract.pop('reshaped_input_sizes'      )  # pop reshaped_input_sizes as it is popped in the processor

				for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()      ,     input_processor[key].sum()      ,     delta=1e-2      )





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_image_processor()

				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=SCREAMING_SNAKE_CASE      )
				SCREAMING_SNAKE_CASE_								=						[tf.ones((1, 3, 5, 5)      )]

				SCREAMING_SNAKE_CASE_								=						[[1764, 2646]]

				SCREAMING_SNAKE_CASE_								=						[[683, 1024]]
				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='tf'      )
				self.assertEqual(masks[0].shape      ,     (1, 3, 1764, 2646)      )

				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(
				    SCREAMING_SNAKE_CASE      ,     tf.convert_to_tensor(SCREAMING_SNAKE_CASE      )      ,     tf.convert_to_tensor(SCREAMING_SNAKE_CASE      )      ,     return_tensors='tf'      ,     )
				self.assertEqual(masks[0].shape      ,     (1, 3, 1764, 2646)      )

				# should also work with np
				SCREAMING_SNAKE_CASE_								=						[np.ones((1, 3, 5, 5)      )]
				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(
				    SCREAMING_SNAKE_CASE      ,     np.array(SCREAMING_SNAKE_CASE      )      ,     np.array(SCREAMING_SNAKE_CASE      )      ,     return_tensors='tf'      )

				self.assertEqual(masks[0].shape      ,     (1, 3, 1764, 2646)      )

				SCREAMING_SNAKE_CASE_								=						[[1, 0], [0, 1]]
				with self.assertRaises(tf.errors.InvalidArgumentError      ):
							SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(
							    SCREAMING_SNAKE_CASE      ,     np.array(SCREAMING_SNAKE_CASE      )      ,     np.array(SCREAMING_SNAKE_CASE      )      ,     return_tensors='tf'      )




@require_vision
@require_torchvision
class       a_       (     unittest.TestCase     ):





	def 						A_(							self      )  ->					int:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						tempfile.mkdtemp()
				SCREAMING_SNAKE_CASE_								=						SamImageProcessor()
				SCREAMING_SNAKE_CASE_								=						SamProcessor(SCREAMING_SNAKE_CASE      )
				processor.save_pretrained(self.tmpdirname      )





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




				"""simple docstring"""



				return AutoProcessor.from_pretrained(self.tmpdirname      ,     **SCREAMING_SNAKE_CASE      ).image_processor





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				shutil.rmtree(self.tmpdirname      )





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						[np.random.randint(255      ,     size=(3, 30, 400)      ,     dtype=np.uinta      )]

				SCREAMING_SNAKE_CASE_								=						[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE      ,     0      ,     -1      )      ) for x in image_inputs]

				return image_inputs





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_image_processor()

				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=SCREAMING_SNAKE_CASE      )
				SCREAMING_SNAKE_CASE_								=						np.random.randint(0      ,     2      ,     size=(1, 3, 5, 5)      ).astype(np.floataa      )
				SCREAMING_SNAKE_CASE_								=						[tf.convert_to_tensor(SCREAMING_SNAKE_CASE      )]
				SCREAMING_SNAKE_CASE_								=						[torch.tensor(SCREAMING_SNAKE_CASE      )]

				SCREAMING_SNAKE_CASE_								=						[[1764, 2646]]

				SCREAMING_SNAKE_CASE_								=						[[683, 1024]]
				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(
				    SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='tf'      )
				SCREAMING_SNAKE_CASE_								=						processor.post_process_masks(
				    SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )

				self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()      )      )





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




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_image_processor()

				SCREAMING_SNAKE_CASE_								=						SamProcessor(image_processor=SCREAMING_SNAKE_CASE      )

				SCREAMING_SNAKE_CASE_								=						self.prepare_image_inputs()

				SCREAMING_SNAKE_CASE_								=						image_processor(SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )['pixel_values'].numpy()
				SCREAMING_SNAKE_CASE_								=						processor(images=SCREAMING_SNAKE_CASE      ,     return_tensors='pt'      )['pixel_values'].numpy()

				SCREAMING_SNAKE_CASE_								=						image_processor(SCREAMING_SNAKE_CASE      ,     return_tensors='tf'      )['pixel_values'].numpy()
				SCREAMING_SNAKE_CASE_								=						processor(images=SCREAMING_SNAKE_CASE      ,     return_tensors='tf'      )['pixel_values'].numpy()

				self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )      )
				self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )      )
				self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )      )






from packaging import version

from .import_utils import is_accelerate_available


if is_accelerate_available():
				import accelerate

def lowercase    (  SCREAMING_SNAKE_CASE )			->							Union[str, Any]:


			'''simple docstring'''







			if not is_accelerate_available():
						return method
			SCREAMING_SNAKE_CASE_								=						version.parse(accelerate.__version__ ).base_version
			if version.parse(SCREAMING_SNAKE_CASE ) < version.parse('0.17.0' ):
						return method

			def wrapper(self       ,    *SCREAMING_SNAKE_CASE       ,    **SCREAMING_SNAKE_CASE ):
						if hasattr(self       ,    '_hf_hook' ) and hasattr(self._hf_hook       ,    'pre_forward' ):
									self._hf_hook.pre_forward(self )
						return method(self       ,    *SCREAMING_SNAKE_CASE       ,    **SCREAMING_SNAKE_CASE )

			return wrapper
