
'''simple docstring'''
import textwrap

import pyarrow as pa
import pytest

from datasets import Features, Value
from datasets.packaged_modules.json.json import Json







@pytest.fixture
def 							A_  (    __SCREAMING_SNAKE_CASE    :	List[Any]			)					->							List[Any]:





  """simple docstring"""

  __A		:  Union[str, Any]       				=		tmp_path / """file.jsonl"""
  __A		:  str       				=		textwrap.dedent(
      """\
        {\"col_1\": -1}
        {\"col_1\": 1, \"col_2\": 2}
        {\"col_1\": 10, \"col_2\": 20}
        """			)
  with open(__SCREAMING_SNAKE_CASE      ,  """w"""			) as f:
    f.write(__SCREAMING_SNAKE_CASE			)
  return str(__SCREAMING_SNAKE_CASE			)







@pytest.fixture
def 							A_  (    __SCREAMING_SNAKE_CASE    :	List[Any]			)					->							int:





  """simple docstring"""

  __A		:  List[Any]       				=		tmp_path / """file_utf16_encoded.jsonl"""
  __A		:  Dict       				=		textwrap.dedent(
      """\
        {\"col_1\": -1}
        {\"col_1\": 1, \"col_2\": 2}
        {\"col_1\": 10, \"col_2\": 20}
        """			)
  with open(__SCREAMING_SNAKE_CASE      ,  """w"""      ,  encoding="""utf-16"""			) as f:
    f.write(__SCREAMING_SNAKE_CASE			)
  return str(__SCREAMING_SNAKE_CASE			)







@pytest.fixture
def 							A_  (    __SCREAMING_SNAKE_CASE    :	int			)					->							int:





  """simple docstring"""

  __A		:  Any       				=		tmp_path / """file_with_list_of_dicts.json"""
  __A		:  str       				=		textwrap.dedent(
      """\
        [
            {\"col_1\": -1},
            {\"col_1\": 1, \"col_2\": 2},
            {\"col_1\": 10, \"col_2\": 20}
        ]
        """			)
  with open(__SCREAMING_SNAKE_CASE      ,  """w"""			) as f:
    f.write(__SCREAMING_SNAKE_CASE			)
  return str(__SCREAMING_SNAKE_CASE			)







@pytest.fixture
def 							A_  (    __SCREAMING_SNAKE_CASE    :	List[str]			)					->							Optional[int]:





  """simple docstring"""

  __A		:  Optional[Any]       				=		tmp_path / """file_with_list_of_dicts_field.json"""
  __A		:  Union[str, Any]       				=		textwrap.dedent(
      """\
        {
            \"field1\": 1,
            \"field2\": \"aabb\",
            \"field3\": [
                {\"col_1\": -1},
                {\"col_1\": 1, \"col_2\": 2},
                {\"col_1\": 10, \"col_2\": 20}
            ]
        }
        """			)
  with open(__SCREAMING_SNAKE_CASE      ,  """w"""			) as f:
    f.write(__SCREAMING_SNAKE_CASE			)
  return str(__SCREAMING_SNAKE_CASE			)







@pytest.mark.parametrize(
    """file_fixture, config_kwargs"""      ,  [
        ("""jsonl_file""", {}),
        ("""jsonl_file_utf16_encoded""", {"""encoding""": """utf-16"""}),
        ("""json_file_with_list_of_dicts""", {}),
        ("""json_file_with_list_of_dicts_field""", {"""field""": """field3"""}),
    ]      ,  )
def 							A_  (    __SCREAMING_SNAKE_CASE    :	Tuple      ,  __SCREAMING_SNAKE_CASE    :	Dict      ,  __SCREAMING_SNAKE_CASE    :	int			)					->							int:





  """simple docstring"""

  __A		:  Optional[Any]       				=		Json(**__SCREAMING_SNAKE_CASE			)
  __A		:  Optional[int]       				=		json._generate_tables([[request.getfixturevalue(__SCREAMING_SNAKE_CASE			)]]			)
  __A		:  List[Any]       				=		pa.concat_tables([table for _, table in generator]			)
  assert pa_table.to_pydict() == {"col_1": [-1, 1, 10], "col_2": [None, 2, 20]}







@pytest.mark.parametrize(
    """file_fixture, config_kwargs"""      ,  [
        (
            """jsonl_file""",
            {"""features""": Features({"""col_1""": Value("""int64"""			), """col_2""": Value("""int64"""			), """missing_col""": Value("""string"""			)}			)},
        ),
        (
            """json_file_with_list_of_dicts""",
            {"""features""": Features({"""col_1""": Value("""int64"""			), """col_2""": Value("""int64"""			), """missing_col""": Value("""string"""			)}			)},
        ),
        (
            """json_file_with_list_of_dicts_field""",
            {
                """field""": """field3""",
                """features""": Features(
                    {"""col_1""": Value("""int64"""			), """col_2""": Value("""int64"""			), """missing_col""": Value("""string"""			)}			),
            },
        ),
    ]      ,  )
def 							A_  (    __SCREAMING_SNAKE_CASE    :	Optional[Any]      ,  __SCREAMING_SNAKE_CASE    :	str      ,  __SCREAMING_SNAKE_CASE    :	Optional[Any]			)					->							Tuple:





  """simple docstring"""

  __A		:  Any       				=		Json(**__SCREAMING_SNAKE_CASE			)
  __A		:  Optional[Any]       				=		json._generate_tables([[request.getfixturevalue(__SCREAMING_SNAKE_CASE			)]]			)
  __A		:  List[str]       				=		pa.concat_tables([table for _, table in generator]			)
  assert pa_table.to_pydict() == {"col_1": [-1, 1, 10], "col_2": [None, 2, 20], "missing_col": [None, None, None]}





'''simple docstring'''
import copy

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


A__ :		str					=logging.get_logger(__name__)

A__ :		Optional[int]					={
    '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 			__A					(			_SCREAMING_SNAKE_CASE      ):
 def __init__( self      :     Tuple					, lowerCamelCase      :     Tuple=2_56					, lowerCamelCase      :     Union[str, Any]=10_24					, lowerCamelCase      :     List[str]=16					, lowerCamelCase      :     str=16					, lowerCamelCase      :     Union[str, Any]=4					, lowerCamelCase      :     Optional[Any]="gelu"					, lowerCamelCase      :     Union[str, Any]=1e-6					, **lowerCamelCase      :     Union[str, Any]					, ):



   """simple docstring"""





   super().__init__(**lowerCamelCase							)
   __A		:  List[str]       				=		hidden_size
   __A		:  Any       				=		image_size
   __A		:  Dict       				=		patch_size
   __A		:  Union[str, Any]       				=		image_size // patch_size
   __A		:  List[Any]       				=		mask_input_channels
   __A		:  str       				=		num_point_embeddings
   __A		:  Tuple       				=		hidden_act
   __A		:  List[str]       				=		layer_norm_eps







class 			__A					(			_SCREAMING_SNAKE_CASE      ):
 def __init__( self      :     Optional[int]					, lowerCamelCase      :     int=2_56					, lowerCamelCase      :     Tuple="relu"					, lowerCamelCase      :     Optional[Any]=20_48					, lowerCamelCase      :     int=2					, lowerCamelCase      :     Tuple=8					, lowerCamelCase      :     int=2					, lowerCamelCase      :     List[str]=3					, lowerCamelCase      :     Dict=3					, lowerCamelCase      :     Any=2_56					, lowerCamelCase      :     int=1e-6					, **lowerCamelCase      :     Tuple					, ):



   """simple docstring"""





   super().__init__(**lowerCamelCase							)
   __A		:  List[Any]       				=		hidden_size
   __A		:  Union[str, Any]       				=		hidden_act
   __A		:  Tuple       				=		mlp_dim
   __A		:  Any       				=		num_hidden_layers
   __A		:  Dict       				=		num_attention_heads
   __A		:  Optional[Any]       				=		attention_downsample_rate
   __A		:  List[Any]       				=		num_multimask_outputs
   __A		:  Optional[Any]       				=		iou_head_depth
   __A		:  Optional[int]       				=		iou_head_hidden_dim
   __A		:  Any       				=		layer_norm_eps







class 			__A					(			_SCREAMING_SNAKE_CASE      ):
 def __init__( self      :     Optional[int]					, lowerCamelCase      :     List[str]=7_68					, lowerCamelCase      :     Tuple=2_56					, lowerCamelCase      :     Optional[Any]=12					, lowerCamelCase      :     Tuple=12					, lowerCamelCase      :     int=3					, lowerCamelCase      :     Dict=10_24					, lowerCamelCase      :     int=16					, lowerCamelCase      :     Any="gelu"					, lowerCamelCase      :     Tuple=1e-0_6					, lowerCamelCase      :     Optional[int]=0.0					, lowerCamelCase      :     List[str]=1e-1_0					, lowerCamelCase      :     Optional[int]=True					, lowerCamelCase      :     Union[str, Any]=4.0					, lowerCamelCase      :     List[Any]=True					, lowerCamelCase      :     Optional[Any]=True					, lowerCamelCase      :     str=14					, lowerCamelCase      :     str=[2, 5, 8, 11]					, lowerCamelCase      :     Dict=1_28					, lowerCamelCase      :     Any=None					, **lowerCamelCase      :     Optional[int]					, ):



   """simple docstring"""





   super().__init__(**lowerCamelCase							)

   __A		:  Any       				=		hidden_size
   __A		:  Union[str, Any]       				=		output_channels
   __A		:  int       				=		num_hidden_layers
   __A		:  Any       				=		num_attention_heads
   __A		:  Tuple       				=		num_channels
   __A		:  Tuple       				=		image_size
   __A		:  Optional[Any]       				=		patch_size
   __A		:  List[str]       				=		hidden_act
   __A		:  Dict       				=		layer_norm_eps
   __A		:  Optional[int]       				=		attention_dropout
   __A		:  Dict       				=		initializer_range
   __A		:  Union[str, Any]       				=		qkv_bias
   __A		:  Optional[Any]       				=		mlp_ratio
   __A		:  Optional[int]       				=		use_abs_pos
   __A		:  int       				=		use_rel_pos
   __A		:  str       				=		window_size
   __A		:  Union[str, Any]       				=		global_attn_indexes
   __A		:  Dict       				=		num_pos_feats
   __A		:  int       				=		int(hidden_size * mlp_ratio							) if mlp_dim is None else mlp_dim







class 			__A					(			_SCREAMING_SNAKE_CASE      ):
 lowerCamelCase												='''sam'''
 lowerCamelCase												=True
 def __init__( self      :     Optional[int]					, lowerCamelCase      :     Dict=None					, lowerCamelCase      :     Dict=None					, lowerCamelCase      :     Optional[Any]=None					, lowerCamelCase      :     List[Any]=0.02					, **lowerCamelCase      :     Any					, ):



   """simple docstring"""





   super().__init__(**lowerCamelCase							)
   __A		:  str       				=		vision_config if vision_config is not None else {}
   __A		:  int       				=		prompt_encoder_config if prompt_encoder_config is not None else {}
   __A		:  Dict       				=		mask_decoder_config if mask_decoder_config is not None else {}

   if isinstance(lowerCamelCase					, lowerCamelCase							):
     __A		:  List[str]       				=		vision_config.to_dict()
   if isinstance(lowerCamelCase					, lowerCamelCase							):
     __A		:  Any       				=		prompt_encoder_config.to_dict()
   if isinstance(lowerCamelCase					, lowerCamelCase							):
     __A		:  Any       				=		mask_decoder_config.to_dict()

   __A		:  Any       				=		SamVisionConfig(**lowerCamelCase							)
   __A		:  List[Any]       				=		SamPromptEncoderConfig(**lowerCamelCase							)
   __A		:  Union[str, Any]       				=		SamMaskDecoderConfig(**lowerCamelCase							)
   __A		:  Any       				=		initializer_range






 def 		lowercase_( self      :     List[Any]							):



   """simple docstring"""





   __A		:  str       				=		copy.deepcopy(self.__dict__							)
   __A		:  Dict       				=		self.vision_config.to_dict()
   __A		:  Any       				=		self.prompt_encoder_config.to_dict()
   __A		:  str       				=		self.mask_decoder_config.to_dict()
   __A		:  Optional[int]       				=		self.__class__.model_type
   return output



