






import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_longformer import LongformerTokenizer


snake_case_   :	Optional[Any]							      =logging.get_logger(__name__)

snake_case_   :	str							      ={'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}

snake_case_   :	List[Any]							      ={
    '''vocab_file''': {
        '''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json''',
        '''allenai/longformer-large-4096''': (
            '''https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json'''
        ),
        '''allenai/longformer-large-4096-finetuned-triviaqa''': (
            '''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json'''
        ),
        '''allenai/longformer-base-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json'''
        ),
        '''allenai/longformer-large-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json'''
        ),
    },
    '''merges_file''': {
        '''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt''',
        '''allenai/longformer-large-4096''': (
            '''https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt'''
        ),
        '''allenai/longformer-large-4096-finetuned-triviaqa''': (
            '''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt'''
        ),
        '''allenai/longformer-base-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt'''
        ),
        '''allenai/longformer-large-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''allenai/longformer-base-4096''': (
            '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/tokenizer.json'''
        ),
        '''allenai/longformer-large-4096''': (
            '''https://huggingface.co/allenai/longformer-large-4096/resolve/main/tokenizer.json'''
        ),
        '''allenai/longformer-large-4096-finetuned-triviaqa''': (
            '''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/tokenizer.json'''
        ),
        '''allenai/longformer-base-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/tokenizer.json'''
        ),
        '''allenai/longformer-large-4096-extra.pos.embd.only''': (
            '''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/tokenizer.json'''
        ),
    },
}

snake_case_   :	Any							      ={
    '''allenai/longformer-base-4096''': 4096,
    '''allenai/longformer-large-4096''': 4096,
    '''allenai/longformer-large-4096-finetuned-triviaqa''': 4096,
    '''allenai/longformer-base-4096-extra.pos.embd.only''': 4096,
    '''allenai/longformer-large-4096-extra.pos.embd.only''': 4096,
}





class        a__      (	lowerCAmelCase__		):
		UpperCAmelCase_							:       List[Any] 					= VOCAB_FILES_NAMES
		UpperCAmelCase_							:       Union[str, Any] 					= PRETRAINED_VOCAB_FILES_MAP
		UpperCAmelCase_							:       Tuple 					= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		UpperCAmelCase_							:       Optional[int] 					= ['input_ids', 'attention_mask']
		UpperCAmelCase_							:       Optional[Any] 					= LongformerTokenizer






		def __init__(      self							, lowercase__=None							, lowercase__=None							, lowercase__=None							, lowercase__="replace"							, lowercase__="<s>"							, lowercase__="</s>"							, lowercase__="</s>"							, lowercase__="<s>"							, lowercase__="<unk>"							, lowercase__="<pad>"							, lowercase__="<mask>"							, lowercase__=False							, lowercase__=True							, **lowercase__							, )				->				Union[str, Any]:
				super().__init__(
				    lowercase__							, lowercase__							, tokenizer_file=lowercase__							, errors=lowercase__							, bos_token=lowercase__							, eos_token=lowercase__							, sep_token=lowercase__							, cls_token=lowercase__							, unk_token=lowercase__							, pad_token=lowercase__							, mask_token=lowercase__							, add_prefix_space=lowercase__							, trim_offsets=lowercase__							, **lowercase__							, )

				__A    =							json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()						)
				if pre_tok_state.get("add_prefix_space"							, lowercase__						) != add_prefix_space:
						__A    =							getattr(lowercase__							, pre_tok_state.pop("type"						)						)
						__A    =							add_prefix_space
						__A    =							pre_tok_class(**lowercase__						)

				__A    =							add_prefix_space

				__A    =							"post_processor"
				__A    =							getattr(self.backend_tokenizer							, lowercase__							, lowercase__						)
				if tokenizer_component_instance:
						__A    =							json.loads(tokenizer_component_instance.__getstate__()						)

						# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
						if "sep" in state:
								__A    =							tuple(state["sep"]						)
						if "cls" in state:
								__A    =							tuple(state["cls"]						)

						__A    =							False

						if state.get("add_prefix_space"							, lowercase__						) != add_prefix_space:
								__A    =							add_prefix_space
								__A    =							True

						if state.get("trim_offsets"							, lowercase__						) != trim_offsets:
								__A    =							trim_offsets
								__A    =							True

						if changes_to_apply:
								__A    =							getattr(lowercase__							, state.pop("type"						)						)
								__A    =							component_class(**lowercase__						)
								setattr(self.backend_tokenizer							, lowercase__							, lowercase__						)






		@property
		def 					_lowerCamelCase					(      self						)				->				str:
				if self._mask_token is None:
						if self.verbose:
								logger.error("Using mask_token, but it is not set yet."						)
						return None
				return str(self._mask_token						)






		@mask_token.setter
		def 					_lowerCamelCase					(      self							, lowercase__						)				->				Optional[Any]:
				__A    =							AddedToken(lowercase__							, lstrip=lowercase__							, rstrip=lowercase__						) if isinstance(lowercase__							, lowercase__						) else value
				__A    =							value






		def 					_lowerCamelCase					(      self							, *lowercase__							, **lowercase__						)				->				BatchEncoding:
				__A    =							kwargs.get("is_split_into_words"							, lowercase__						)
				assert self.add_prefix_space or not is_split_into_words, (
				    F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
				    "to use it with pretokenized inputs."
				)

				return super()._batch_encode_plus(*lowercase__							, **lowercase__						)






		def 					_lowerCamelCase					(      self							, *lowercase__							, **lowercase__						)				->				BatchEncoding:
				__A    =							kwargs.get("is_split_into_words"							, lowercase__						)

				assert self.add_prefix_space or not is_split_into_words, (
				    F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
				    "to use it with pretokenized inputs."
				)

				return super()._encode_plus(*lowercase__							, **lowercase__						)






		def 					_lowerCamelCase					(      self							, lowercase__							, lowercase__ = None						)				->				Tuple[str]:
				__A    =							self._tokenizer.model.save(lowercase__							, name=lowercase__						)
				return tuple(lowercase__						)






		def 					_lowerCamelCase					(      self							, lowercase__							, lowercase__=None						)				->				int:
				__A    =							[self.bos_token_id] + token_ids_a + [self.eos_token_id]
				if token_ids_a is None:
						return output

				return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]






		def 					_lowerCamelCase					(      self							, lowercase__							, lowercase__ = None						)				->				List[int]:
				__A    =							[self.sep_token_id]
				__A    =							[self.cls_token_id]

				if token_ids_a is None:
						return len(cls + token_ids_a + sep						) * [0]
				return len(cls + token_ids_a + sep + sep + token_ids_a + sep						) * [0]









"""simple docstring"""

import copy

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


lowercase           =							logging.get_logger(__name__)

lowercase           =							{
    '''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_				(   snake_case_	):







				def __init__(				self				:    List[Any]    ,     __lowerCamelCase				:    str=2_5_6    ,     __lowerCamelCase				:    str=1_0_2_4    ,     __lowerCamelCase				:    Optional[Any]=1_6    ,     __lowerCamelCase				:    Union[str, Any]=1_6    ,     __lowerCamelCase				:    str=4    ,     __lowerCamelCase				:    Union[str, Any]="gelu"    ,     __lowerCamelCase				:    Optional[int]=1e-6    ,     **__lowerCamelCase				:    str    ,     )					->       List[Any]:
										super().__init__(**__lowerCamelCase						)
										__magic_name__      =  hidden_size
										__magic_name__      =  image_size
										__magic_name__      =  patch_size
										__magic_name__      =  image_size // patch_size
										__magic_name__      =  mask_input_channels
										__magic_name__      =  num_point_embeddings
										__magic_name__      =  hidden_act
										__magic_name__      =  layer_norm_eps





class     A_				(   snake_case_	):







				def __init__(				self				:    List[str]    ,     __lowerCamelCase				:    Optional[Any]=2_5_6    ,     __lowerCamelCase				:    int="relu"    ,     __lowerCamelCase				:    List[str]=2_0_4_8    ,     __lowerCamelCase				:    Optional[Any]=2    ,     __lowerCamelCase				:    Optional[Any]=8    ,     __lowerCamelCase				:    Optional[Any]=2    ,     __lowerCamelCase				:    Dict=3    ,     __lowerCamelCase				:    Optional[int]=3    ,     __lowerCamelCase				:    Tuple=2_5_6    ,     __lowerCamelCase				:    List[str]=1e-6    ,     **__lowerCamelCase				:    Any    ,     )					->       str:
										super().__init__(**__lowerCamelCase						)
										__magic_name__      =  hidden_size
										__magic_name__      =  hidden_act
										__magic_name__      =  mlp_dim
										__magic_name__      =  num_hidden_layers
										__magic_name__      =  num_attention_heads
										__magic_name__      =  attention_downsample_rate
										__magic_name__      =  num_multimask_outputs
										__magic_name__      =  iou_head_depth
										__magic_name__      =  iou_head_hidden_dim
										__magic_name__      =  layer_norm_eps





class     A_				(   snake_case_	):







				def __init__(				self				:    Union[str, Any]    ,     __lowerCamelCase				:    str=7_6_8    ,     __lowerCamelCase				:    Optional[int]=2_5_6    ,     __lowerCamelCase				:    Tuple=1_2    ,     __lowerCamelCase				:    int=1_2    ,     __lowerCamelCase				:    int=3    ,     __lowerCamelCase				:    int=1_0_2_4    ,     __lowerCamelCase				:    Any=1_6    ,     __lowerCamelCase				:    Tuple="gelu"    ,     __lowerCamelCase				:    Dict=1e-06    ,     __lowerCamelCase				:    List[Any]=0.0    ,     __lowerCamelCase				:    Optional[Any]=1e-10    ,     __lowerCamelCase				:    str=True    ,     __lowerCamelCase				:    List[str]=4.0    ,     __lowerCamelCase				:    Union[str, Any]=True    ,     __lowerCamelCase				:    str=True    ,     __lowerCamelCase				:    Optional[Any]=1_4    ,     __lowerCamelCase				:    str=[2, 5, 8, 1_1]    ,     __lowerCamelCase				:    List[Any]=1_2_8    ,     __lowerCamelCase				:    Dict=None    ,     **__lowerCamelCase				:    List[str]    ,     )					->       Optional[int]:
										super().__init__(**__lowerCamelCase						)

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





class     A_				(   snake_case_	):
				UpperCAmelCase__										=					'''sam'''
				UpperCAmelCase__										=					True







				def __init__(				self				:    Optional[Any]    ,     __lowerCamelCase				:    Dict=None    ,     __lowerCamelCase				:    Dict=None    ,     __lowerCamelCase				:    Optional[Any]=None    ,     __lowerCamelCase				:    int=0.02    ,     **__lowerCamelCase				:    List[Any]    ,     )					->       List[str]:
										super().__init__(**__lowerCamelCase						)
										__magic_name__      =  vision_config if vision_config is not None else {}
										__magic_name__      =  prompt_encoder_config if prompt_encoder_config is not None else {}
										__magic_name__      =  mask_decoder_config if mask_decoder_config is not None else {}

										if isinstance(__lowerCamelCase    ,     __lowerCamelCase						):
																__magic_name__      =  vision_config.to_dict()
										if isinstance(__lowerCamelCase    ,     __lowerCamelCase						):
																__magic_name__      =  prompt_encoder_config.to_dict()
										if isinstance(__lowerCamelCase    ,     __lowerCamelCase						):
																__magic_name__      =  mask_decoder_config.to_dict()

										__magic_name__      =  SamVisionConfig(**__lowerCamelCase						)
										__magic_name__      =  SamPromptEncoderConfig(**__lowerCamelCase						)
										__magic_name__      =  SamMaskDecoderConfig(**__lowerCamelCase						)
										__magic_name__      =  initializer_range







				def      _snake_case       (				self				:    Optional[int]						)					->       str:
										__magic_name__      =  copy.deepcopy(self.__dict__						)
										__magic_name__      =  self.vision_config.to_dict()
										__magic_name__      =  self.prompt_encoder_config.to_dict()
										__magic_name__      =  self.mask_decoder_config.to_dict()
										__magic_name__      =  self.__class__.model_type
										return output



