



import unittest

import numpy as np

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 EfficientNetImageProcessor






class 				SCREAMING_SNAKE_CASE     (							unittest.TestCase   ):





							def __init__(				self						:						Any ,			__lowercase						:						str ,			__lowercase						:						Union[str, Any]=13 ,			__lowercase						:						int=3 ,			__lowercase						:						Optional[Any]=18 ,			__lowercase						:						Tuple=30 ,			__lowercase						:						List[Any]=400 ,			__lowercase						:						Optional[int]=True ,			__lowercase						:						int=None ,			__lowercase						:						List[str]=True ,			__lowercase						:						Optional[int]=[0.5, 0.5, 0.5] ,			__lowercase						:						Any=[0.5, 0.5, 0.5] ,			):

											'''simple docstring'''
											__a					       =						size if size is not None else {"""height""": 18, """width""": 18}
											__a					       =						parent
											__a					       =						batch_size
											__a					       =						num_channels
											__a					       =						image_size
											__a					       =						min_resolution
											__a					       =						max_resolution
											__a					       =						do_resize
											__a					       =						size
											__a					       =						do_normalize
											__a					       =						image_mean
											__a					       =						image_std







							def   UpperCamelCase_   (				self						:						int		):

											'''simple docstring'''
											return {
											    "image_mean": self.image_mean,
											    "image_std": self.image_std,
											    "do_normalize": self.do_normalize,
											    "do_resize": self.do_resize,
											    "size": self.size,
											}






@require_torch
@require_vision
class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__     , unittest.TestCase   ):
							__lowerCamelCase		:		Tuple      =EfficientNetImageProcessor if is_vision_available() else None





							def   UpperCamelCase_   (				self						:						List[str]		):

											'''simple docstring'''
											__a					       =						EfficientNetImageProcessorTester(self		)





							@property
							def   UpperCamelCase_   (				self						:						int		):

											'''simple docstring'''
											return self.image_processor_tester.prepare_image_processor_dict()





							def   UpperCamelCase_   (				self						:						List[Any]		):

											'''simple docstring'''
											__a					       =						self.image_processing_class(**self.image_processor_dict		)
											self.assertTrue(hasattr(__lowercase ,			"""image_mean"""		)		)
											self.assertTrue(hasattr(__lowercase ,			"""image_std"""		)		)
											self.assertTrue(hasattr(__lowercase ,			"""do_normalize"""		)		)
											self.assertTrue(hasattr(__lowercase ,			"""do_resize"""		)		)
											self.assertTrue(hasattr(__lowercase ,			"""size"""		)		)





							def   UpperCamelCase_   (				self						:						Union[str, Any]		):

											'''simple docstring'''
											__a					       =						self.image_processing_class.from_dict(self.image_processor_dict		)
											self.assertEqual(image_processor.size ,			{"""height""": 18, """width""": 18}		)

											__a					       =						self.image_processing_class.from_dict(self.image_processor_dict ,			size=42		)
											self.assertEqual(image_processor.size ,			{"""height""": 42, """width""": 42}		)





							def   UpperCamelCase_   (				self						:						Dict		):

											'''simple docstring'''
											# Initialize image_processing
											__a					       =						self.image_processing_class(**self.image_processor_dict		)
											# create random PIL images
											__a					       =						prepare_image_inputs(self.image_processor_tester ,			equal_resolution=__lowercase		)
											for image in image_inputs:
															self.assertIsInstance(__lowercase ,			Image.Image		)

											# Test not batched input
											__a					       =						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.size["""height"""],
											        self.image_processor_tester.size["""width"""],
											    ) ,			)

											# Test batched
											__a					       =						image_processing(__lowercase ,			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.size["""height"""],
											        self.image_processor_tester.size["""width"""],
											    ) ,			)





							def   UpperCamelCase_   (				self						:						Tuple		):

											'''simple docstring'''
											# Initialize image_processing
											__a					       =						self.image_processing_class(**self.image_processor_dict		)
											# create random numpy tensors
											__a					       =						prepare_image_inputs(self.image_processor_tester ,			equal_resolution=__lowercase ,			numpify=__lowercase		)
											for image in image_inputs:
															self.assertIsInstance(__lowercase ,			np.ndarray		)

											# Test not batched input
											__a					       =						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.size["""height"""],
											        self.image_processor_tester.size["""width"""],
											    ) ,			)

											# Test batched
											__a					       =						image_processing(__lowercase ,			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.size["""height"""],
											        self.image_processor_tester.size["""width"""],
											    ) ,			)







							def   UpperCamelCase_   (				self						:						str		):

											'''simple docstring'''
											# Initialize image_processing
											__a					       =						self.image_processing_class(**self.image_processor_dict		)
											# create random PyTorch tensors
											__a					       =						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
											__a					       =						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.size["""height"""],
											        self.image_processor_tester.size["""width"""],
											    ) ,			)

											# Test batched
											__a					       =						image_processing(__lowercase ,			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.size["""height"""],
											        self.image_processor_tester.size["""width"""],
											    ) ,			)





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase__     =	logging.get_logger(__name__)

lowerCamelCase__     =	{
    """facebook/sam-vit-huge""": """https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json""",
    """facebook/sam-vit-large""": """https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json""",
    """facebook/sam-vit-base""": """https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json""",
}






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						List[Any] ,			__lowercase						:						Optional[Any]=256 ,			__lowercase						:						Optional[int]=1024 ,			__lowercase						:						Any=16 ,			__lowercase						:						Optional[Any]=16 ,			__lowercase						:						Optional[Any]=4 ,			__lowercase						:						Optional[int]="gelu" ,			__lowercase						:						List[Any]=1E-6 ,			**__lowercase						:						str ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						hidden_size
											__a					       =						image_size
											__a					       =						patch_size
											__a					       =						image_size // patch_size
											__a					       =						mask_input_channels
											__a					       =						num_point_embeddings
											__a					       =						hidden_act
											__a					       =						layer_norm_eps






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						int ,			__lowercase						:						Tuple=256 ,			__lowercase						:						List[Any]="relu" ,			__lowercase						:						Any=2048 ,			__lowercase						:						List[Any]=2 ,			__lowercase						:						List[str]=8 ,			__lowercase						:						Any=2 ,			__lowercase						:						List[Any]=3 ,			__lowercase						:						str=3 ,			__lowercase						:						str=256 ,			__lowercase						:						Optional[Any]=1E-6 ,			**__lowercase						:						Tuple ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						hidden_size
											__a					       =						hidden_act
											__a					       =						mlp_dim
											__a					       =						num_hidden_layers
											__a					       =						num_attention_heads
											__a					       =						attention_downsample_rate
											__a					       =						num_multimask_outputs
											__a					       =						iou_head_depth
											__a					       =						iou_head_hidden_dim
											__a					       =						layer_norm_eps






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						List[Any] ,			__lowercase						:						List[Any]=768 ,			__lowercase						:						List[Any]=256 ,			__lowercase						:						Any=12 ,			__lowercase						:						Tuple=12 ,			__lowercase						:						Union[str, Any]=3 ,			__lowercase						:						Tuple=1024 ,			__lowercase						:						Any=16 ,			__lowercase						:						Dict="gelu" ,			__lowercase						:						List[Any]=1E-06 ,			__lowercase						:						List[str]=0.0 ,			__lowercase						:						Optional[Any]=1E-10 ,			__lowercase						:						Optional[Any]=True ,			__lowercase						:						str=4.0 ,			__lowercase						:						List[Any]=True ,			__lowercase						:						Dict=True ,			__lowercase						:						Optional[Any]=14 ,			__lowercase						:						Optional[int]=[2, 5, 8, 11] ,			__lowercase						:						List[str]=128 ,			__lowercase						:						Optional[int]=None ,			**__lowercase						:						List[Any] ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)

											__a					       =						hidden_size
											__a					       =						output_channels
											__a					       =						num_hidden_layers
											__a					       =						num_attention_heads
											__a					       =						num_channels
											__a					       =						image_size
											__a					       =						patch_size
											__a					       =						hidden_act
											__a					       =						layer_norm_eps
											__a					       =						attention_dropout
											__a					       =						initializer_range
											__a					       =						qkv_bias
											__a					       =						mlp_ratio
											__a					       =						use_abs_pos
											__a					       =						use_rel_pos
											__a					       =						window_size
											__a					       =						global_attn_indexes
											__a					       =						num_pos_feats
											__a					       =						int(hidden_size * mlp_ratio		) if mlp_dim is None else mlp_dim






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):
							__lowerCamelCase		:		Dict      ='sam'
							__lowerCamelCase		:		Any      =True





							def __init__(				self						:						List[str] ,			__lowercase						:						List[str]=None ,			__lowercase						:						Optional[int]=None ,			__lowercase						:						Dict=None ,			__lowercase						:						Optional[int]=0.02 ,			**__lowercase						:						List[str] ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						vision_config if vision_config is not None else {}
											__a					       =						prompt_encoder_config if prompt_encoder_config is not None else {}
											__a					       =						mask_decoder_config if mask_decoder_config is not None else {}

											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						vision_config.to_dict()
											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						prompt_encoder_config.to_dict()
											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						mask_decoder_config.to_dict()

											__a					       =						SamVisionConfig(**__lowercase		)
											__a					       =						SamPromptEncoderConfig(**__lowercase		)
											__a					       =						SamMaskDecoderConfig(**__lowercase		)
											__a					       =						initializer_range







							def   UpperCamelCase_   (				self						:						Union[str, Any]		):

											'''simple docstring'''
											__a					       =						copy.deepcopy(self.__dict__		)
											__a					       =						self.vision_config.to_dict()
											__a					       =						self.prompt_encoder_config.to_dict()
											__a					       =						self.mask_decoder_config.to_dict()
											__a					       =						self.__class__.model_type
											return output
