"""simple docstring"""






import torch



def 						a_		(      ):







				if torch.cuda.is_available():
								UpperCAmelCase__    =							torch.cuda.device_count()
				else:
								UpperCAmelCase__    =							0
				print(f'''Successfully ran on {num_gpus} GPUs''' )


if __name__ == "__main__":
						main()




"""simple docstring"""






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        snake_case (				unittest.TestCase       ):




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							tempfile.mkdtemp()
									UpperCAmelCase__    =							SamImageProcessor()
									UpperCAmelCase__    =							SamProcessor(lowerCamelCase__    )
									processor.save_pretrained(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			str					,**lowerCamelCase__     :			Dict    ):
									return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase__    ).image_processor







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									shutil.rmtree(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta    )]

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

									return image_inputs







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							SamProcessor(image_processor=self.get_image_processor()    )
									processor.save_pretrained(self.tmpdirname    )

									UpperCAmelCase__    =							self.get_image_processor(do_normalize=lowerCamelCase__					,padding_value=1.0    )

									UpperCAmelCase__    =							SamProcessor.from_pretrained(self.tmpdirname					,do_normalize=lowerCamelCase__					,padding_value=1.0    )

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







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )

									UpperCAmelCase__    =							self.prepare_image_inputs()

									UpperCAmelCase__    =							image_processor(lowerCamelCase__					,return_tensors='np'    )
									UpperCAmelCase__    =							processor(images=lowerCamelCase__					,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 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )
									UpperCAmelCase__    =							[torch.ones((1, 3, 5, 5)    )]

									UpperCAmelCase__    =							[[1_764, 2_646]]

									UpperCAmelCase__    =							[[683, 1_024]]
									UpperCAmelCase__    =							processor.post_process_masks(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,torch.tensor(lowerCamelCase__    )					,torch.tensor(lowerCamelCase__    )    )
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

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

									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

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






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




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__    =							tempfile.mkdtemp()
									UpperCAmelCase__    =							SamImageProcessor()
									UpperCAmelCase__    =							SamProcessor(lowerCamelCase__    )
									processor.save_pretrained(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			str					,**lowerCamelCase__     :			Union[str, Any]    ):
									return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase__    ).image_processor







					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									shutil.rmtree(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			Any    ):
									UpperCAmelCase__    =							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta    )]

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

									return image_inputs







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									UpperCAmelCase__    =							SamProcessor(image_processor=self.get_image_processor()    )
									processor.save_pretrained(self.tmpdirname    )

									UpperCAmelCase__    =							self.get_image_processor(do_normalize=lowerCamelCase__					,padding_value=1.0    )

									UpperCAmelCase__    =							SamProcessor.from_pretrained(self.tmpdirname					,do_normalize=lowerCamelCase__					,padding_value=1.0    )

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







					def 	__lowerCAmelCase		(       self     :			Union[str, Any]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )

									UpperCAmelCase__    =							self.prepare_image_inputs()

									UpperCAmelCase__    =							image_processor(lowerCamelCase__					,return_tensors='np'    )
									UpperCAmelCase__    =							processor(images=lowerCamelCase__					,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 	__lowerCAmelCase		(       self     :			Tuple    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )
									UpperCAmelCase__    =							[tf.ones((1, 3, 5, 5)    )]

									UpperCAmelCase__    =							[[1_764, 2_646]]

									UpperCAmelCase__    =							[[683, 1_024]]
									UpperCAmelCase__    =							processor.post_process_masks(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,return_tensors='tf'    )
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,tf.convert_to_tensor(lowerCamelCase__    )					,tf.convert_to_tensor(lowerCamelCase__    )					,return_tensors='tf'					,)
									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

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

									self.assertEqual(masks[0].shape					,(1, 3, 1_764, 2_646)    )

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






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




					"""simple docstring"""

					def 	__lowerCAmelCase		(       self     :			Any    ):
									UpperCAmelCase__    =							tempfile.mkdtemp()
									UpperCAmelCase__    =							SamImageProcessor()
									UpperCAmelCase__    =							SamProcessor(lowerCamelCase__    )
									processor.save_pretrained(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			Dict					,**lowerCamelCase__     :			Any    ):
									return AutoProcessor.from_pretrained(self.tmpdirname					,**lowerCamelCase__    ).image_processor







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									shutil.rmtree(self.tmpdirname    )







					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									UpperCAmelCase__    =							[np.random.randint(255					,size=(3, 30, 400)					,dtype=np.uinta    )]

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

									return image_inputs







					@is_pt_tf_cross_test
					def 	__lowerCAmelCase		(       self     :			List[Any]    ):
									UpperCAmelCase__    =							self.get_image_processor()

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

									UpperCAmelCase__    =							[[1_764, 2_646]]

									UpperCAmelCase__    =							[[683, 1_024]]
									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,return_tensors='tf'    )
									UpperCAmelCase__    =							processor.post_process_masks(
									    lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,return_tensors='pt'    )

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







					@is_pt_tf_cross_test
					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									UpperCAmelCase__    =							self.get_image_processor()

									UpperCAmelCase__    =							SamProcessor(image_processor=lowerCamelCase__    )

									UpperCAmelCase__    =							self.prepare_image_inputs()

									UpperCAmelCase__    =							image_processor(lowerCamelCase__					,return_tensors='pt'    )['pixel_values'].numpy()
									UpperCAmelCase__    =							processor(images=lowerCamelCase__					,return_tensors='pt'    )['pixel_values'].numpy()

									UpperCAmelCase__    =							image_processor(lowerCamelCase__					,return_tensors='tf'    )['pixel_values'].numpy()
									UpperCAmelCase__    =							processor(images=lowerCamelCase__					,return_tensors='tf'    )['pixel_values'].numpy()

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



