





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


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import TvltImageProcessor



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE=10					,		_SCREAMING_SNAKE_CASE=10					,		_SCREAMING_SNAKE_CASE=False					,		_SCREAMING_SNAKE_CASE=False      )					->  Optional[Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		[]
      for i in range(image_processor_tester.num_frames      ):
            video.append(np.random.randint(2_55					,		size=(image_processor_tester.num_channels, width, height)					,		dtype=np.uinta      )      )

      if not numpify and not torchify:
            # PIL expects the channel dimension as last dimension
            SCREAMING_SNAKE_CASE						=		[Image.fromarray(np.moveaxis(_SCREAMING_SNAKE_CASE					,		0					,		-1      )      ) for frame in video]

      if torchify:
            SCREAMING_SNAKE_CASE						=		[torch.from_numpy(_SCREAMING_SNAKE_CASE      ) for frame in video]

      return video



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE=False					,		_SCREAMING_SNAKE_CASE=False					,		_SCREAMING_SNAKE_CASE=False      )					->  Tuple:


      '''simple docstring'''


      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

      SCREAMING_SNAKE_CASE						=		[]
      for i in range(image_processor_tester.batch_size      ):
            if equal_resolution:
                  SCREAMING_SNAKE_CASE						=		SCREAMING_SNAKE_CASE						=		image_processor_tester.max_resolution
            else:
                  SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		np.random.choice(
                      np.arange(image_processor_tester.min_resolution					,		image_processor_tester.max_resolution      )					,		2      )
                  SCREAMING_SNAKE_CASE						=		prepare_video(
                      image_processor_tester=_SCREAMING_SNAKE_CASE					,		width=_SCREAMING_SNAKE_CASE					,		height=_SCREAMING_SNAKE_CASE					,		numpify=_SCREAMING_SNAKE_CASE					,		torchify=_SCREAMING_SNAKE_CASE					,		)
            video_inputs.append(_SCREAMING_SNAKE_CASE      )

      return video_inputs

class 						UpperCamelCase__					( unittest.TestCase  ):



     '''simple docstring'''

     def __init__(				self		:       Union[str, Any]		,lowerCamelCase__		:       Tuple		,lowerCamelCase__		:       Any=7		,lowerCamelCase__		:       str=3		,lowerCamelCase__		:       Union[str, Any]=4		,lowerCamelCase__		:       Union[str, Any]=18		,lowerCamelCase__		:       Any=30		,lowerCamelCase__		:       Union[str, Any]=400		,lowerCamelCase__		:       Any=True		,lowerCamelCase__		:       Any=None		,lowerCamelCase__		:       Tuple=True		,lowerCamelCase__		:       int=[0.5, 0.5, 0.5]		,lowerCamelCase__		:       Any=[0.5, 0.5, 0.5]		,lowerCamelCase__		:       Dict=True		,lowerCamelCase__		:       Tuple=None		,)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		size if size is not None else {"""shortest_edge""": 18}
           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						=		num_frames
           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_normalize
           SCREAMING_SNAKE_CASE						=		image_mean
           SCREAMING_SNAKE_CASE						=		image_std
           SCREAMING_SNAKE_CASE						=		do_center_crop
           SCREAMING_SNAKE_CASE						=		crop_size






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						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,
               "do_center_crop": self.do_center_crop,
               "crop_size": self.crop_size,
           }

@require_torch
@require_vision
class 						UpperCamelCase__					( lowerCAmelCase_				, unittest.TestCase  ):



     '''simple docstring'''

     __snake_case       :      int						      =     TvltImageProcessor if is_vision_available() else None






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		TvltImageProcessorTester(self			)






     @property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Dict:




           '''simple docstring'''


           return self.image_processor_tester.prepare_image_processor_dict()






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.image_processing_class(**self.image_processor_dict			)
           self.assertTrue(hasattr(lowerCamelCase__		,"""image_mean"""			)			)
           self.assertTrue(hasattr(lowerCamelCase__		,"""image_std"""			)			)
           self.assertTrue(hasattr(lowerCamelCase__		,"""do_normalize"""			)			)
           self.assertTrue(hasattr(lowerCamelCase__		,"""do_resize"""			)			)
           self.assertTrue(hasattr(lowerCamelCase__		,"""do_center_crop"""			)			)
           self.assertTrue(hasattr(lowerCamelCase__		,"""size"""			)			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.image_processing_class(**self.image_processor_dict			)
           # create random PIL videos
           SCREAMING_SNAKE_CASE						=		prepare_video_inputs(self.image_processor_tester		,equal_resolution=lowerCamelCase__			)
           for video in video_inputs:
                 self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__			)
                 self.assertIsInstance(video[0]		,Image.Image			)

           # Test not batched input
           SCREAMING_SNAKE_CASE						=		image_processor(video_inputs[0]		,return_tensors="""pt"""			).pixel_values
           self.assertEqual(
               encoded_videos.shape		,(
                   1,
                   self.image_processor_tester.num_frames,
                   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_processor(lowerCamelCase__		,return_tensors="""pt"""			).pixel_values
           self.assertEqual(
               encoded_videos.shape		,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       int			)	->						int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.image_processing_class(**self.image_processor_dict			)
           # create random numpy tensors
           SCREAMING_SNAKE_CASE						=		prepare_video_inputs(self.image_processor_tester		,equal_resolution=lowerCamelCase__		,numpify=lowerCamelCase__			)
           for video in video_inputs:
                 self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__			)
                 self.assertIsInstance(video[0]		,np.ndarray			)

           # Test not batched input
           SCREAMING_SNAKE_CASE						=		image_processor(video_inputs[0]		,return_tensors="""pt"""			).pixel_values
           self.assertEqual(
               encoded_videos.shape		,(
                   1,
                   self.image_processor_tester.num_frames,
                   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_processor(lowerCamelCase__		,return_tensors="""pt"""			).pixel_values
           self.assertEqual(
               encoded_videos.shape		,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.image_processing_class(**self.image_processor_dict			)
           # create random PyTorch tensors
           SCREAMING_SNAKE_CASE						=		prepare_video_inputs(self.image_processor_tester		,equal_resolution=lowerCamelCase__		,torchify=lowerCamelCase__			)
           for video in video_inputs:
                 self.assertIsInstance(lowerCamelCase__		,lowerCamelCase__			)
                 self.assertIsInstance(video[0]		,torch.Tensor			)

           # Test not batched input
           SCREAMING_SNAKE_CASE						=		image_processor(video_inputs[0]		,return_tensors="""pt"""			).pixel_values
           self.assertEqual(
               encoded_videos.shape		,(
                   1,
                   self.image_processor_tester.num_frames,
                   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_processor(lowerCamelCase__		,return_tensors="""pt"""			).pixel_values
           self.assertEqual(
               encoded_videos.shape		,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_frames,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)









import copy

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


SCREAMING_SNAKE_CASE_		  =			logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_		  =			{
    """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 						UpperCamelCase__					( lowerCAmelCase_  ):



     '''simple docstring'''

     def __init__(				self		:       List[str]		,lowerCamelCase__		:       int=256		,lowerCamelCase__		:       List[Any]=1024		,lowerCamelCase__		:       Any=16		,lowerCamelCase__		:       Union[str, Any]=16		,lowerCamelCase__		:       int=4		,lowerCamelCase__		:       Tuple="gelu"		,lowerCamelCase__		:       Dict=1e-6		,**lowerCamelCase__		:       int		,)	->						List[str]:




           '''simple docstring'''


           super().__init__(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		hidden_size
           SCREAMING_SNAKE_CASE						=		image_size
           SCREAMING_SNAKE_CASE						=		patch_size
           SCREAMING_SNAKE_CASE						=		image_size // patch_size
           SCREAMING_SNAKE_CASE						=		mask_input_channels
           SCREAMING_SNAKE_CASE						=		num_point_embeddings
           SCREAMING_SNAKE_CASE						=		hidden_act
           SCREAMING_SNAKE_CASE						=		layer_norm_eps

class 						UpperCamelCase__					( lowerCAmelCase_  ):



     '''simple docstring'''

     def __init__(				self		:       str		,lowerCamelCase__		:       str=256		,lowerCamelCase__		:       Optional[Any]="relu"		,lowerCamelCase__		:       str=2048		,lowerCamelCase__		:       Union[str, Any]=2		,lowerCamelCase__		:       int=8		,lowerCamelCase__		:       Union[str, Any]=2		,lowerCamelCase__		:       List[Any]=3		,lowerCamelCase__		:       int=3		,lowerCamelCase__		:       Optional[Any]=256		,lowerCamelCase__		:       Tuple=1e-6		,**lowerCamelCase__		:       List[str]		,)	->						Dict:




           '''simple docstring'''


           super().__init__(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		hidden_size
           SCREAMING_SNAKE_CASE						=		hidden_act
           SCREAMING_SNAKE_CASE						=		mlp_dim
           SCREAMING_SNAKE_CASE						=		num_hidden_layers
           SCREAMING_SNAKE_CASE						=		num_attention_heads
           SCREAMING_SNAKE_CASE						=		attention_downsample_rate
           SCREAMING_SNAKE_CASE						=		num_multimask_outputs
           SCREAMING_SNAKE_CASE						=		iou_head_depth
           SCREAMING_SNAKE_CASE						=		iou_head_hidden_dim
           SCREAMING_SNAKE_CASE						=		layer_norm_eps

class 						UpperCamelCase__					( lowerCAmelCase_  ):



     '''simple docstring'''

     def __init__(				self		:       Union[str, Any]		,lowerCamelCase__		:       Optional[Any]=768		,lowerCamelCase__		:       Union[str, Any]=256		,lowerCamelCase__		:       Optional[int]=12		,lowerCamelCase__		:       str=12		,lowerCamelCase__		:       Tuple=3		,lowerCamelCase__		:       Optional[Any]=1024		,lowerCamelCase__		:       Optional[int]=16		,lowerCamelCase__		:       Optional[Any]="gelu"		,lowerCamelCase__		:       int=1e-0_6		,lowerCamelCase__		:       Optional[Any]=0.0		,lowerCamelCase__		:       Tuple=1e-1_0		,lowerCamelCase__		:       Any=True		,lowerCamelCase__		:       List[Any]=4.0		,lowerCamelCase__		:       Optional[int]=True		,lowerCamelCase__		:       Union[str, Any]=True		,lowerCamelCase__		:       List[str]=14		,lowerCamelCase__		:       List[str]=[2, 5, 8, 11]		,lowerCamelCase__		:       Tuple=128		,lowerCamelCase__		:       Dict=None		,**lowerCamelCase__		:       Optional[Any]		,)	->						str:




           '''simple docstring'''


           super().__init__(**lowerCamelCase__			)

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

class 						UpperCamelCase__					( lowerCAmelCase_  ):



     '''simple docstring'''

     __snake_case       :      Any						      =     "sam"
     __snake_case       :      Optional[Any]						      =     True






     def __init__(				self		:       Union[str, Any]		,lowerCamelCase__		:       List[Any]=None		,lowerCamelCase__		:       int=None		,lowerCamelCase__		:       int=None		,lowerCamelCase__		:       int=0.02		,**lowerCamelCase__		:       int		,)	->						str:




           '''simple docstring'''


           super().__init__(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		vision_config if vision_config is not None else {}
           SCREAMING_SNAKE_CASE						=		prompt_encoder_config if prompt_encoder_config is not None else {}
           SCREAMING_SNAKE_CASE						=		mask_decoder_config if mask_decoder_config is not None else {}

           if isinstance(lowerCamelCase__		,lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		vision_config.to_dict()
           if isinstance(lowerCamelCase__		,lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		prompt_encoder_config.to_dict()
           if isinstance(lowerCamelCase__		,lowerCamelCase__			):
                 SCREAMING_SNAKE_CASE						=		mask_decoder_config.to_dict()

           SCREAMING_SNAKE_CASE						=		SamVisionConfig(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		SamPromptEncoderConfig(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		SamMaskDecoderConfig(**lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		initializer_range






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		copy.deepcopy(self.__dict__			)
           SCREAMING_SNAKE_CASE						=		self.vision_config.to_dict()
           SCREAMING_SNAKE_CASE						=		self.prompt_encoder_config.to_dict()
           SCREAMING_SNAKE_CASE						=		self.mask_decoder_config.to_dict()
           SCREAMING_SNAKE_CASE						=		self.__class__.model_type
           return output


