

import copy
import os
from typing import Union

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


lowerCAmelCase							:  Union[str, Any]            =						logging.get_logger(__name__)

lowerCAmelCase							:  int            =						{
    """google/pix2struct-textcaps-base""": (
        """https://huggingface.co/google/pix2struct-textcaps-base/resolve/main/config.json"""
    ),
}



class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			_UpperCAmelCase       :							Any      							=					'''pix2struct_text_model'''
			_UpperCAmelCase       :							Optional[Any]      							=					['''past_key_values''']
			_UpperCAmelCase       :							Optional[int]      							=					{
			    '''hidden_size''': '''hidden_size''',
			    '''num_attention_heads''': '''num_heads''',
			    '''num_hidden_layers''': '''num_layers''',
			}



			def __init__(			self  :					str       ,						lowerCAmelCase__  :					Union[str, Any]=5_0244       ,						lowerCAmelCase__  :					str=768       ,						lowerCAmelCase__  :					Any=64       ,						lowerCAmelCase__  :					Tuple=2048       ,						lowerCAmelCase__  :					int=12       ,						lowerCAmelCase__  :					int=12       ,						lowerCAmelCase__  :					Tuple=32       ,						lowerCAmelCase__  :					str=128       ,						lowerCAmelCase__  :					str=0.1       ,						lowerCAmelCase__  :					Any=1E-6       ,						lowerCAmelCase__  :					int=1.0       ,						lowerCAmelCase__  :					List[Any]="gelu_new"       ,						lowerCAmelCase__  :					Dict=0       ,						lowerCAmelCase__  :					str=False       ,						lowerCAmelCase__  :					Optional[Any]=0       ,						lowerCAmelCase__  :					Optional[int]=1       ,						lowerCAmelCase__  :					int=False       ,						lowerCAmelCase__  :					Optional[Any]=True       ,						**lowerCAmelCase__  :					Optional[Any]       ,						):
									SCREAMING_SNAKE_CASE_:			Any  		=	vocab_size
									SCREAMING_SNAKE_CASE_:			List[str]  		=	hidden_size
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	d_kv
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	d_ff
									SCREAMING_SNAKE_CASE_:			str  		=	num_layers
									SCREAMING_SNAKE_CASE_:			Tuple  		=	num_heads
									SCREAMING_SNAKE_CASE_:			Dict  		=	relative_attention_num_buckets
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	relative_attention_max_distance
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	dropout_rate
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	layer_norm_epsilon
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	initializer_factor
									SCREAMING_SNAKE_CASE_:			Any  		=	use_cache

									SCREAMING_SNAKE_CASE_:			int  		=	eos_token_id
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	decoder_start_token_id

									# for backwards compatibility
									SCREAMING_SNAKE_CASE_:			Any  		=	dense_act_fn

									super().__init__(
									    pad_token_id=lowerCAmelCase__       ,						eos_token_id=lowerCAmelCase__       ,						decoder_start_token_id=lowerCAmelCase__       ,						tie_word_embeddings=lowerCAmelCase__       ,						is_decoder=lowerCAmelCase__       ,						**lowerCAmelCase__       ,						)




			@classmethod
			def 	_SCREAMING_SNAKE_CASE      (			cls  :					Any       ,						lowerCAmelCase__  :					Union[str, os.PathLike]       ,						**lowerCAmelCase__  :					List[str]):
									cls._set_token_in_kwargs(lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_		,   SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	cls.get_config_dict(lowerCAmelCase__       ,						**lowerCAmelCase__)

									# get the text config dict if we are loading from Pix2StructConfig
									if config_dict.get("model_type") == "pix2struct":
															SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	config_dict["text_config"]

									if "model_type" in config_dict and hasattr(cls       ,						"model_type") and config_dict["model_type"] != cls.model_type:
															logger.warning(
															    F"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
															    F"{cls.model_type}. This is not supported for all configurations of models and can yield errors.")

									return cls.from_dict(lowerCAmelCase__       ,						**lowerCAmelCase__)







class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			_UpperCAmelCase       :							List[str]      							=					'''pix2struct_vision_model'''



			def __init__(			self  :					List[str]       ,						lowerCAmelCase__  :					List[Any]=768       ,						lowerCAmelCase__  :					int=768       ,						lowerCAmelCase__  :					str=2048       ,						lowerCAmelCase__  :					List[str]=64       ,						lowerCAmelCase__  :					Any=12       ,						lowerCAmelCase__  :					int=12       ,						lowerCAmelCase__  :					Any="gelu_new"       ,						lowerCAmelCase__  :					Dict=1E-6       ,						lowerCAmelCase__  :					int=0.0       ,						lowerCAmelCase__  :					int=0.0       ,						lowerCAmelCase__  :					str=1E-10       ,						lowerCAmelCase__  :					Dict=1.0       ,						lowerCAmelCase__  :					Union[str, Any]=4096       ,						lowerCAmelCase__  :					List[str]=32       ,						lowerCAmelCase__  :					Optional[Any]=128       ,						**lowerCAmelCase__  :					Union[str, Any]       ,						):
									super().__init__(**lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			List[Any]  		=	hidden_size
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	patch_embed_hidden_size
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	d_ff
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	dropout_rate
									SCREAMING_SNAKE_CASE_:			str  		=	num_hidden_layers
									SCREAMING_SNAKE_CASE_:			Tuple  		=	num_attention_heads
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	initializer_range
									SCREAMING_SNAKE_CASE_:			List[str]  		=	initializer_factor
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	attention_dropout
									SCREAMING_SNAKE_CASE_:			List[str]  		=	layer_norm_eps
									SCREAMING_SNAKE_CASE_:			str  		=	dense_act_fn
									SCREAMING_SNAKE_CASE_:			List[str]  		=	seq_len
									SCREAMING_SNAKE_CASE_:			Any  		=	relative_attention_num_buckets
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	relative_attention_max_distance
									SCREAMING_SNAKE_CASE_:			int  		=	d_kv




			@classmethod
			def 	_SCREAMING_SNAKE_CASE      (			cls  :					Any       ,						lowerCAmelCase__  :					Union[str, os.PathLike]       ,						**lowerCAmelCase__  :					Optional[int]):
									cls._set_token_in_kwargs(lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_		,   SCREAMING_SNAKE_CASE_:			Dict  		=	cls.get_config_dict(lowerCAmelCase__       ,						**lowerCAmelCase__)

									# get the vision config dict if we are loading from Pix2StructConfig
									if config_dict.get("model_type") == "pix2struct":
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	config_dict["vision_config"]

									if "model_type" in config_dict and hasattr(cls       ,						"model_type") and config_dict["model_type"] != cls.model_type:
															logger.warning(
															    F"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
															    F"{cls.model_type}. This is not supported for all configurations of models and can yield errors.")

									return cls.from_dict(lowerCAmelCase__       ,						**lowerCAmelCase__)







class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			_UpperCAmelCase       :							int      							=					'''pix2struct'''
			_UpperCAmelCase       :							int      							=					True



			def __init__(			self  :					Tuple       ,						lowerCAmelCase__  :					List[str]=None       ,						lowerCAmelCase__  :					List[str]=None       ,						lowerCAmelCase__  :					List[Any]=1.0       ,						lowerCAmelCase__  :					Tuple=0.02       ,						lowerCAmelCase__  :					Any=False       ,						lowerCAmelCase__  :					int=False       ,						lowerCAmelCase__  :					str=True       ,						**lowerCAmelCase__  :					Tuple       ,						):
									super().__init__(tie_word_embeddings=lowerCAmelCase__       ,						is_encoder_decoder=lowerCAmelCase__       ,						**lowerCAmelCase__)

									if text_config is None:
															SCREAMING_SNAKE_CASE_:			int  		=	{}
															logger.info("text_config is None. Initializing the Pix2StructTextConfig with default values.")

									if vision_config is None:
															SCREAMING_SNAKE_CASE_:			Tuple  		=	{}
															logger.info("vision_config is None. Initializing the Pix2StructVisionConfig with default values.")

									SCREAMING_SNAKE_CASE_:			List[Any]  		=	PixaStructTextConfig(**lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	PixaStructVisionConfig(**lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	self.text_config.decoder_start_token_id
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	self.text_config.pad_token_id
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	self.text_config.eos_token_id

									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	initializer_factor
									SCREAMING_SNAKE_CASE_:			Dict  		=	initializer_range

									SCREAMING_SNAKE_CASE_:			str  		=	self.initializer_range
									SCREAMING_SNAKE_CASE_:			int  		=	self.initializer_range

									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	is_vqa



			@classmethod
			def 	_SCREAMING_SNAKE_CASE      (			cls  :					Optional[int]       ,						lowerCAmelCase__  :					PixaStructTextConfig       ,						lowerCAmelCase__  :					PixaStructVisionConfig       ,						**lowerCAmelCase__  :					Optional[int]):
									return cls(text_config=text_config.to_dict()       ,						vision_config=vision_config.to_dict()       ,						**lowerCAmelCase__)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]):
									SCREAMING_SNAKE_CASE_:			Tuple  		=	copy.deepcopy(self.__dict__)
									SCREAMING_SNAKE_CASE_:			str  		=	self.text_config.to_dict()
									SCREAMING_SNAKE_CASE_:			Any  		=	self.vision_config.to_dict()
									SCREAMING_SNAKE_CASE_:			str  		=	self.__class__.model_type
									return output









from typing import Dict, List, Optional

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


lowerCAmelCase							:  List[str]            =						logging.get_logger(__name__)


lowerCAmelCase							:  Tuple            =						{
    """nielsr/canine-s""": 2048,
}

# Unicode defines 1,114,112 total “codepoints”
lowerCAmelCase							:  Any            =						1114112

# Below: Constants defining canonical codepoints for special, pseudo-characters.
# Copied from https://github.com/google-research/language/blob/master/language/canine/special_codepoints.py
lowerCAmelCase							:  Dict            =						0

lowerCAmelCase							:  Dict            =						0xe000
lowerCAmelCase							:  str            =						0xe001
lowerCAmelCase							:  str            =						0xe002
lowerCAmelCase							:  Optional[int]            =						0xe003
lowerCAmelCase							:  List[Any]            =						0xe004

# Maps special codepoints to human-readable names.
lowerCAmelCase							:  Dict[int, str]            =						{
    # Special symbols are represented using codepoints values that are valid,
    # but designated as "Private Use", meaning that they will never be assigned
    # characters by the Unicode Consortium, and are thus safe for use here.
    #
    # NOTE: Do *NOT* add any sort of [UNK_CHAR] here. They are explicitly
    # excluded and should fail with a hard error.
    CLS: "[CLS]",
    SEP: "[SEP]",
    BOS: "[BOS]",
    MASK: "[MASK]",
    PAD: "[PAD]",
    RESERVED: "[RESERVED]",
}

# Maps special codepoint human-readable names to their codepoint values.
lowerCAmelCase							:  Dict[str, int]            =						{name: codepoint for codepoint, name in SPECIAL_CODEPOINTS.items()}



class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			_UpperCAmelCase       :							List[str]      							=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES



			def __init__(			self  :					Optional[Any]       ,						lowerCAmelCase__  :					Tuple=chr(lowerCAmelCase__)       ,						lowerCAmelCase__  :					Tuple=chr(lowerCAmelCase__)       ,						lowerCAmelCase__  :					str=chr(lowerCAmelCase__)       ,						lowerCAmelCase__  :					List[Any]=chr(lowerCAmelCase__)       ,						lowerCAmelCase__  :					Optional[int]=chr(lowerCAmelCase__)       ,						lowerCAmelCase__  :					Union[str, Any]=chr(lowerCAmelCase__)       ,						lowerCAmelCase__  :					Union[str, Any]=False       ,						lowerCAmelCase__  :					int=2048       ,						**lowerCAmelCase__  :					Tuple       ,						):
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	AddedToken(lowerCAmelCase__       ,						lstrip=lowerCAmelCase__       ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__) else bos_token
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	AddedToken(lowerCAmelCase__       ,						lstrip=lowerCAmelCase__       ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__) else eos_token
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	AddedToken(lowerCAmelCase__       ,						lstrip=lowerCAmelCase__       ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__) else sep_token
									SCREAMING_SNAKE_CASE_:			Any  		=	AddedToken(lowerCAmelCase__       ,						lstrip=lowerCAmelCase__       ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__) else cls_token
									SCREAMING_SNAKE_CASE_:			str  		=	AddedToken(lowerCAmelCase__       ,						lstrip=lowerCAmelCase__       ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__) else pad_token

									# Mask token behave like a normal word, i.e. include the space before it
									SCREAMING_SNAKE_CASE_:			Dict  		=	AddedToken(lowerCAmelCase__       ,						lstrip=lowerCAmelCase__       ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__) else mask_token

									super().__init__(
									    bos_token=lowerCAmelCase__       ,						eos_token=lowerCAmelCase__       ,						sep_token=lowerCAmelCase__       ,						cls_token=lowerCAmelCase__       ,						pad_token=lowerCAmelCase__       ,						mask_token=lowerCAmelCase__       ,						add_prefix_space=lowerCAmelCase__       ,						model_max_length=lowerCAmelCase__       ,						**lowerCAmelCase__       ,						)

									# Creates a mapping for looking up the IDs of special symbols.
									SCREAMING_SNAKE_CASE_:			Dict[str, int]  		=	{}
									for codepoint, name in SPECIAL_CODEPOINTS.items():
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	codepoint

									# Creates a mapping for looking up the string forms of special symbol IDs.
									SCREAMING_SNAKE_CASE_:			Dict[int, str]  		=	{
									    codepoint: name for name, codepoint in self._special_codepoints.items()
									}

									SCREAMING_SNAKE_CASE_:			List[str]  		=	UNICODE_VOCAB_SIZE
									SCREAMING_SNAKE_CASE_:			Tuple  		=	len(self._special_codepoints)



			@property
			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]):
									return self._unicode_vocab_size



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Dict       ,						lowerCAmelCase__  :					str):
									return list(lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]       ,						lowerCAmelCase__  :					str):
									try:
															return ord(lowerCAmelCase__)
									except TypeError:
															raise ValueError(F"invalid token: '{token}'")



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]       ,						lowerCAmelCase__  :					int):
									try:
															if index in SPECIAL_CODEPOINTS:
																					return SPECIAL_CODEPOINTS[index]
															return chr(lowerCAmelCase__)
									except TypeError:
															raise ValueError(F"invalid id: {index}")



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]       ,						lowerCAmelCase__  :					Dict):
									return "".join(lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]       ,						lowerCAmelCase__  :					List[int]       ,						lowerCAmelCase__  :					Optional[List[int]] = None):
									SCREAMING_SNAKE_CASE_:			List[str]  		=	[self.sep_token_id]
									SCREAMING_SNAKE_CASE_:			Tuple  		=	[self.cls_token_id]

									SCREAMING_SNAKE_CASE_:			int  		=	cls + token_ids_a + sep
									if token_ids_a is not None:
															result += token_ids_a + sep
									return result



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Union[str, Any]       ,						lowerCAmelCase__  :					List[int]       ,						lowerCAmelCase__  :					Optional[List[int]] = None       ,						lowerCAmelCase__  :					bool = False):
									if already_has_special_tokens:
															return super().get_special_tokens_mask(
															    token_ids_a=lowerCAmelCase__       ,						token_ids_a=lowerCAmelCase__       ,						already_has_special_tokens=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			Any  		=	[1] + ([0] * len(lowerCAmelCase__)) + [1]
									if token_ids_a is not None:
															result += ([0] * len(lowerCAmelCase__)) + [1]
									return result



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Dict       ,						lowerCAmelCase__  :					List[int]       ,						lowerCAmelCase__  :					Optional[List[int]] = None):
									SCREAMING_SNAKE_CASE_:			Dict  		=	[self.sep_token_id]
									SCREAMING_SNAKE_CASE_:			int  		=	[self.cls_token_id]

									SCREAMING_SNAKE_CASE_:			List[str]  		=	len(cls + token_ids_a + sep) * [0]
									if token_ids_a is not None:
															result += len(token_ids_a + sep) * [1]
									return result




			def 	_SCREAMING_SNAKE_CASE      (			self  :					str       ,						lowerCAmelCase__  :					str       ,						lowerCAmelCase__  :					Optional[str] = None):
									return ()






