




'''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      ):






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






    """simple docstring"""


    A__       =     tempfile.mkdtemp()
    A__       =     SamImageProcessor()
    A__       =     SamProcessor(a    )
    processor.save_pretrained(self.tmpdirname    )






 def 						_UpperCamelCase (self       :  str    ,		**a       :  Optional[int]    )       ->   List[str]:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  int    )       ->   str:






    """simple docstring"""


    shutil.rmtree(self.tmpdirname    )






 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   List[Any]:






    """simple docstring"""


    A__       =     [np.random.randint(2_55    ,		size=(3, 30, 4_00)    ,		dtype=np.uinta    )]

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

    return image_inputs






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






    """simple docstring"""


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

    A__       =     self.get_image_processor(do_normalize=a    ,		padding_value=1.0    )

    A__       =     SamProcessor.from_pretrained(self.tmpdirname    ,		do_normalize=a    ,		padding_value=1.0    )

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






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






    """simple docstring"""


    A__       =     self.get_image_processor()

    A__       =     SamProcessor(image_processor=a    )

    A__       =     self.prepare_image_inputs()

    A__       =     image_processor(a    ,		return_tensors='np'    )
    A__       =     processor(images=a    ,		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 						_UpperCamelCase (self       :  List[Any]    )       ->   Dict:






    """simple docstring"""


    A__       =     self.get_image_processor()

    A__       =     SamProcessor(image_processor=a    )
    A__       =     [torch.ones((1, 3, 5, 5)    )]

    A__       =     [[17_64, 26_46]]

    A__       =     [[6_83, 10_24]]
    A__       =     processor.post_process_masks(a    ,		a    ,		a    )
    self.assertEqual(masks[0].shape    ,		(1, 3, 17_64, 26_46)    )

    A__       =     processor.post_process_masks(
        a    ,		torch.tensor(a    )    ,		torch.tensor(a    )    )
    self.assertEqual(masks[0].shape    ,		(1, 3, 17_64, 26_46)    )

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

    self.assertEqual(masks[0].shape    ,		(1, 3, 17_64, 26_46)    )

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




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






 def 						_UpperCamelCase (self       :  List[Any]    )       ->   Optional[int]:






    """simple docstring"""


    A__       =     tempfile.mkdtemp()
    A__       =     SamImageProcessor()
    A__       =     SamProcessor(a    )
    processor.save_pretrained(self.tmpdirname    )






 def 						_UpperCamelCase (self       :  int    ,		**a       :  List[Any]    )       ->   Union[str, Any]:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   str:






    """simple docstring"""


    shutil.rmtree(self.tmpdirname    )






 def 						_UpperCamelCase (self       :  int    )       ->   Dict:






    """simple docstring"""


    A__       =     [np.random.randint(2_55    ,		size=(3, 30, 4_00)    ,		dtype=np.uinta    )]

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

    return image_inputs






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






    """simple docstring"""


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

    A__       =     self.get_image_processor(do_normalize=a    ,		padding_value=1.0    )

    A__       =     SamProcessor.from_pretrained(self.tmpdirname    ,		do_normalize=a    ,		padding_value=1.0    )

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






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






    """simple docstring"""


    A__       =     self.get_image_processor()

    A__       =     SamProcessor(image_processor=a    )

    A__       =     self.prepare_image_inputs()

    A__       =     image_processor(a    ,		return_tensors='np'    )
    A__       =     processor(images=a    ,		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 						_UpperCamelCase (self       :  int    )       ->   Dict:






    """simple docstring"""


    A__       =     self.get_image_processor()

    A__       =     SamProcessor(image_processor=a    )
    A__       =     [tf.ones((1, 3, 5, 5)    )]

    A__       =     [[17_64, 26_46]]

    A__       =     [[6_83, 10_24]]
    A__       =     processor.post_process_masks(a    ,		a    ,		a    ,		return_tensors='tf'    )
    self.assertEqual(masks[0].shape    ,		(1, 3, 17_64, 26_46)    )

    A__       =     processor.post_process_masks(
        a    ,		tf.convert_to_tensor(a    )    ,		tf.convert_to_tensor(a    )    ,		return_tensors='tf'    ,		)
    self.assertEqual(masks[0].shape    ,		(1, 3, 17_64, 26_46)    )

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

    self.assertEqual(masks[0].shape    ,		(1, 3, 17_64, 26_46)    )

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




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






 def 						_UpperCamelCase (self       :  int    )       ->   List[str]:






    """simple docstring"""


    A__       =     tempfile.mkdtemp()
    A__       =     SamImageProcessor()
    A__       =     SamProcessor(a    )
    processor.save_pretrained(self.tmpdirname    )






 def 						_UpperCamelCase (self       :  List[Any]    ,		**a       :  Union[str, Any]    )       ->   List[str]:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  int    )       ->   Tuple:






    """simple docstring"""


    shutil.rmtree(self.tmpdirname    )






 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   Any:






    """simple docstring"""


    A__       =     [np.random.randint(2_55    ,		size=(3, 30, 4_00)    ,		dtype=np.uinta    )]

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

    return image_inputs






 @is_pt_tf_cross_test
 def 						_UpperCamelCase (self       :  List[Any]    )       ->   Any:






    """simple docstring"""


    A__       =     self.get_image_processor()

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

    A__       =     [[17_64, 26_46]]

    A__       =     [[6_83, 10_24]]
    A__       =     processor.post_process_masks(
        a    ,		a    ,		a    ,		return_tensors='tf'    )
    A__       =     processor.post_process_masks(
        a    ,		a    ,		a    ,		return_tensors='pt'    )

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






 @is_pt_tf_cross_test
 def 						_UpperCamelCase (self       :  int    )       ->   int:






    """simple docstring"""


    A__       =     self.get_image_processor()

    A__       =     SamProcessor(image_processor=a    )

    A__       =     self.prepare_image_inputs()

    A__       =     image_processor(a    ,		return_tensors='pt'    )['pixel_values'].numpy()
    A__       =     processor(images=a    ,		return_tensors='pt'    )['pixel_values'].numpy()

    A__       =     image_processor(a    ,		return_tensors='tf'    )['pixel_values'].numpy()
    A__       =     processor(images=a    ,		return_tensors='tf'    )['pixel_values'].numpy()

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








'''simple docstring'''







from torch import nn







def 						_A      ( UpperCAmelCase						):






   '''simple docstring'''







   if act_fn in ["swish", "silu"]:
      return nn.SiLU()
   elif act_fn == "mish":
      return nn.Mish()
   elif act_fn == "gelu":
      return nn.GELU()
   else:
      raise ValueError(F"""Unsupported activation function: {act_fn}"""						)


