






"""simple docstring"""






import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  ["image_processor", "tokenizer"]
      __UpperCamelCase	 =  "ViTImageProcessor"
      __UpperCamelCase	 =  ("CLIPTokenizer", "CLIPTokenizerFast")
      def __init__(						self     :  str						,	lowercase_     :  Any=None						,	lowercase_     :  Optional[Any]=None						,	**lowercase_     :  int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		None
          if "feature_extractor" in kwargs:
              warnings.warn(
                  '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
                  ''' instead.'''						,	lowercase_						,	)
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		kwargs.pop('''feature_extractor''')

          SCREAMING_SNAKE_CASE_      :  int    						=		image_processor if image_processor is not None else feature_extractor
          if image_processor is None:
              raise ValueError('''You need to specify an `image_processor`.''')
          if tokenizer is None:
              raise ValueError('''You need to specify a `tokenizer`.''')

          super().__init__(lowercase_						,	lowercase_)
      def __call__(						self     :  Optional[Any]						,	lowercase_     :  str=None						,	lowercase_     :  Optional[int]=None						,	lowercase_     :  Dict=None						,	lowercase_     :  List[Any]=None						,	**lowercase_     :  int):




          '''simple docstring'''


          if text is None and visual_prompt is None and images is None:
              raise ValueError('''You have to specify either text, visual prompt or images.''')

          if text is not None and visual_prompt is not None:
              raise ValueError('''You have to specify exactly one type of prompt. Either text or visual prompt.''')

          if text is not None:
              SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.tokenizer(lowercase_						,	return_tensors=lowercase_						,	**lowercase_)

          if visual_prompt is not None:
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.image_processor(lowercase_						,	return_tensors=lowercase_						,	**lowercase_)

          if images is not None:
              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.image_processor(lowercase_						,	return_tensors=lowercase_						,	**lowercase_)

          if visual_prompt is not None and images is not None:
              SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		{
                  '''pixel_values''': image_features.pixel_values,
                  '''conditional_pixel_values''': prompt_features.pixel_values,
              }
              return encoding
          elif text is not None and images is not None:
              SCREAMING_SNAKE_CASE_      :  int    						=		image_features.pixel_values
              return encoding
          elif text is not None:
              return encoding
          elif visual_prompt is not None:
              SCREAMING_SNAKE_CASE_      :  int    						=		{
                  '''conditional_pixel_values''': prompt_features.pixel_values,
              }
              return encoding
          else:
              return BatchEncoding(data=dict(**lowercase_)						,	tensor_type=lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple						,	*lowercase_     :  str						,	**lowercase_     :  List[Any]):




          '''simple docstring'''


          return self.tokenizer.batch_decode(*lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]						,	*lowercase_     :  Union[str, Any]						,	**lowercase_     :  List[str]):




          '''simple docstring'''


          return self.tokenizer.decode(*lowercase_						,	**lowercase_)
      @property
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          warnings.warn(
              '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''						,	lowercase_						,	)
          return self.image_processor_class



      @property
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          warnings.warn(
              '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''						,	lowercase_						,	)
          return self.image_processor










"""simple docstring"""






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


UpperCAmelCase_   : Optional[int]   			= logging.get_logger(__name__)

UpperCAmelCase_   : Any   			= {"""openai-gpt""": """https://huggingface.co/openai-gpt/resolve/main/config.json"""}




class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  "openai-gpt"
      __UpperCamelCase	 =  {
          "max_position_embeddings": "n_positions",
          "hidden_size": "n_embd",
          "num_attention_heads": "n_head",
          "num_hidden_layers": "n_layer",
      }
      def __init__(						self     :  List[str]						,	lowercase_     :  List[str]=40478						,	lowercase_     :  List[str]=512						,	lowercase_     :  Optional[Any]=768						,	lowercase_     :  Tuple=12						,	lowercase_     :  Tuple=12						,	lowercase_     :  Union[str, Any]="gelu"						,	lowercase_     :  List[Any]=0.1						,	lowercase_     :  Tuple=0.1						,	lowercase_     :  List[Any]=0.1						,	lowercase_     :  List[Any]=1e-5						,	lowercase_     :  int=0.02						,	lowercase_     :  Optional[int]="cls_index"						,	lowercase_     :  Any=True						,	lowercase_     :  List[Any]=None						,	lowercase_     :  List[str]=True						,	lowercase_     :  Optional[Any]=0.1						,	**lowercase_     :  List[str]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		vocab_size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		n_positions
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		n_embd
          SCREAMING_SNAKE_CASE_      :  Dict    						=		n_layer
          SCREAMING_SNAKE_CASE_      :  Any    						=		n_head
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		afn
          SCREAMING_SNAKE_CASE_      :  int    						=		resid_pdrop
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		embd_pdrop
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		attn_pdrop
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		layer_norm_epsilon
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		initializer_range
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		summary_type
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		summary_use_proj
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		summary_activation
          SCREAMING_SNAKE_CASE_      :  Any    						=		summary_first_dropout
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		summary_proj_to_labels
          super().__init__(**lowercase_)


