


"""simple docstring"""


from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			['image_processor', 'tokenizer']
		__UpperCamelCase           =			'BlipImageProcessor'
		__UpperCamelCase           =			('BertTokenizer', 'BertTokenizerFast')







		def __init__(					self      :       str    ,   a__      :       Any    ,   a__      :       int		)       ->						str:





						'''simple docstring'''







						_A					  =			False
						super().__init__(a__    ,   a__		)
						_A					  =			self.image_processor







		def __call__(					self      :       List[Any]    ,   a__      :       ImageInput = None    ,   a__      :       Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None    ,   a__      :       bool = True    ,   a__      :       Union[bool, str, PaddingStrategy] = False    ,   a__      :       Union[bool, str, TruncationStrategy] = None    ,   a__      :       Optional[int] = None    ,   a__      :       int = 0    ,   a__      :       Optional[int] = None    ,   a__      :       Optional[bool] = None    ,   a__      :       bool = False    ,   a__      :       bool = False    ,   a__      :       bool = False    ,   a__      :       bool = False    ,   a__      :       bool = False    ,   a__      :       bool = True    ,   a__      :       Optional[Union[str, TensorType]] = None    ,   **a__      :       Dict    ,   )       ->						BatchEncoding:





						'''simple docstring'''







						if images is None and text is None:
										raise ValueError("You have to specify either images or text."		)

						# Get only text
						if images is None:
										_A					  =			self.tokenizer
										_A					  =			self.tokenizer(
										    text=a__    ,   add_special_tokens=a__    ,   padding=a__    ,   truncation=a__    ,   max_length=a__    ,   stride=a__    ,   pad_to_multiple_of=a__    ,   return_attention_mask=a__    ,   return_overflowing_tokens=a__    ,   return_special_tokens_mask=a__    ,   return_offsets_mapping=a__    ,   return_token_type_ids=a__    ,   return_length=a__    ,   verbose=a__    ,   return_tensors=a__    ,   **a__    ,   )
										return text_encoding

						# add pixel_values
						_A					  =			self.image_processor(a__    ,   return_tensors=a__		)

						if text is not None:
										_A					  =			self.tokenizer(
										    text=a__    ,   add_special_tokens=a__    ,   padding=a__    ,   truncation=a__    ,   max_length=a__    ,   stride=a__    ,   pad_to_multiple_of=a__    ,   return_attention_mask=a__    ,   return_overflowing_tokens=a__    ,   return_special_tokens_mask=a__    ,   return_offsets_mapping=a__    ,   return_token_type_ids=a__    ,   return_length=a__    ,   verbose=a__    ,   return_tensors=a__    ,   **a__    ,   )
						else:
										_A					  =			None

						if text_encoding is not None:
										encoding_image_processor.update(a__		)

						return encoding_image_processor







		def  a_ (					self      :       Optional[int]    ,   *a__      :       int    ,   **a__      :       Tuple		)       ->						List[Any]:





						'''simple docstring'''







						return self.tokenizer.batch_decode(*a__    ,   **a__		)







		def  a_ (					self      :       List[Any]    ,   *a__      :       List[str]    ,   **a__      :       Optional[Any]		)       ->						Any:





						'''simple docstring'''







						return self.tokenizer.decode(*a__    ,   **a__		)







		@property
		def  a_ (					self      :       Union[str, Any]		)       ->						Optional[Any]:





						'''simple docstring'''







						_A					  =			self.tokenizer.model_input_names
						_A					  =			self.image_processor.model_input_names
						return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names		)		)



"""simple docstring"""


import copy
import os
from typing import Union

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


a_       							=    logging.get_logger(__name__)

a_       							=    {
    "Salesforce/blip-vqa-base": "https://huggingface.co/Salesforce/blip-vqa-base/resolve/main/config.json",
    "Salesforce/blip-vqa-capfit-large": (
        "https://huggingface.co/Salesforce/blip-vqa-base-capfit/resolve/main/config.json"
    ),
    "Salesforce/blip-image-captioning-base": (
        "https://huggingface.co/Salesforce/blip-image-captioning-base/resolve/main/config.json"
    ),
    "Salesforce/blip-image-captioning-large": (
        "https://huggingface.co/Salesforce/blip-image-captioning-large/resolve/main/config.json"
    ),
    "Salesforce/blip-itm-base-coco": "https://huggingface.co/Salesforce/blip-itm-base-coco/resolve/main/config.json",
    "Salesforce/blip-itm-large-coco": "https://huggingface.co/Salesforce/blip-itm-large-coco/resolve/main/config.json",
    "Salesforce/blip-itm-base-flikr": "https://huggingface.co/Salesforce/blip-itm-base-flikr/resolve/main/config.json",
    "Salesforce/blip-itm-large-flikr": (
        "https://huggingface.co/Salesforce/blip-itm-large-flikr/resolve/main/config.json"
    ),
}
class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			'blip_text_model'







		def __init__(					self      :       int    ,   a__      :       List[str]=3_05_24    ,   a__      :       List[str]=7_68    ,   a__      :       List[Any]=7_68    ,   a__      :       int=30_72    ,   a__      :       List[str]=7_68    ,   a__      :       Dict=12    ,   a__      :       Optional[int]=8    ,   a__      :       Optional[Any]=5_12    ,   a__      :       List[Any]="gelu"    ,   a__      :       Optional[Any]=1E-1_2    ,   a__      :       Any=0.0    ,   a__      :       int=0.0    ,   a__      :       Dict=0.0_2    ,   a__      :       Optional[Any]=3_05_22    ,   a__      :       Any=2    ,   a__      :       int=0    ,   a__      :       Union[str, Any]=1_02    ,   a__      :       Tuple=True    ,   a__      :       Optional[int]=True    ,   **a__      :       Any    ,   )       ->						List[Any]:





						'''simple docstring'''







						super().__init__(
						    pad_token_id=a__    ,   bos_token_id=a__    ,   eos_token_id=a__    ,   sep_token_id=a__    ,   **a__    ,   )

						_A					  =			vocab_size
						_A					  =			hidden_size
						_A					  =			encoder_hidden_size
						_A					  =			intermediate_size
						_A					  =			projection_dim
						_A					  =			hidden_dropout_prob
						_A					  =			num_hidden_layers
						_A					  =			num_attention_heads
						_A					  =			max_position_embeddings
						_A					  =			layer_norm_eps
						_A					  =			hidden_act
						_A					  =			initializer_range
						_A					  =			attention_probs_dropout_prob
						_A					  =			is_decoder
						_A					  =			use_cache







		@classmethod
		def  a_ (					cls      :       Optional[Any]    ,   a__      :       Union[str, os.PathLike]    ,   **a__      :       Optional[Any]		)       ->						"PretrainedConfig":





						'''simple docstring'''







						cls._set_token_in_kwargs(a__		)

						_A  ,		_A					  =			cls.get_config_dict(a__    ,   **a__		)

						# get the text config dict if we are loading from BlipConfig
						if config_dict.get("model_type"		) == "blip":
										_A					  =			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(a__    ,   **a__		)





class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			'blip_vision_model'







		def __init__(					self      :       Optional[Any]    ,   a__      :       Any=7_68    ,   a__      :       List[str]=30_72    ,   a__      :       str=5_12    ,   a__      :       Any=12    ,   a__      :       int=12    ,   a__      :       int=3_84    ,   a__      :       Tuple=16    ,   a__      :       str="gelu"    ,   a__      :       Tuple=1E-5    ,   a__      :       List[str]=0.0    ,   a__      :       List[Any]=1E-1_0    ,   **a__      :       int    ,   )       ->						List[str]:





						'''simple docstring'''







						super().__init__(**a__		)

						_A					  =			hidden_size
						_A					  =			intermediate_size
						_A					  =			projection_dim
						_A					  =			num_hidden_layers
						_A					  =			num_attention_heads
						_A					  =			patch_size
						_A					  =			image_size
						_A					  =			initializer_range
						_A					  =			attention_dropout
						_A					  =			layer_norm_eps
						_A					  =			hidden_act







		@classmethod
		def  a_ (					cls      :       Any    ,   a__      :       Union[str, os.PathLike]    ,   **a__      :       int		)       ->						"PretrainedConfig":





						'''simple docstring'''







						cls._set_token_in_kwargs(a__		)

						_A  ,		_A					  =			cls.get_config_dict(a__    ,   **a__		)

						# get the vision config dict if we are loading from BlipConfig
						if config_dict.get("model_type"		) == "blip":
										_A					  =			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(a__    ,   **a__		)





class snake_case      (  _UpperCamelCase):
		__UpperCamelCase           =			'blip'
		__UpperCamelCase           =			True







		def __init__(					self      :       List[Any]    ,   a__      :       Optional[int]=None    ,   a__      :       str=None    ,   a__      :       List[str]=5_12    ,   a__      :       Any=2.6_5_9_2    ,   a__      :       str=2_56    ,   **a__      :       Optional[int]    ,   )       ->						Dict:





						'''simple docstring'''







						super().__init__(**a__		)

						if text_config is None:
										_A					  =			{}
										logger.info("`text_config` is `None`. Initializing the `BlipTextConfig` with default values."		)

						if vision_config is None:
										_A					  =			{}
										logger.info("`vision_config` is `None`. Initializing the `BlipVisionConfig` with default values."		)

						_A					  =			BlipTextConfig(**a__		)
						_A					  =			BlipVisionConfig(**a__		)

						_A					  =			self.vision_config.hidden_size

						_A					  =			projection_dim
						_A					  =			logit_scale_init_value
						_A					  =			1.0
						_A					  =			0.0_2
						_A					  =			image_text_hidden_size







		@classmethod
		def  a_ (					cls      :       Tuple    ,   a__      :       BlipTextConfig    ,   a__      :       BlipVisionConfig    ,   **a__      :       Optional[int]		)       ->						str:





						'''simple docstring'''







						return cls(text_config=text_config.to_dict()    ,   vision_config=vision_config.to_dict()    ,   **a__		)







		def  a_ (					self      :       Union[str, Any]		)       ->						List[Any]:





						'''simple docstring'''







						_A					  =			copy.deepcopy(self.__dict__		)
						_A					  =			self.text_config.to_dict()
						_A					  =			self.vision_config.to_dict()
						_A					  =			self.__class__.model_type
						return output