
"""simple docstring"""


import json
import re
from typing import TYPE_CHECKING, List, Optional, Tuple, Union

import numpy as np

from ...utils import is_tf_available, is_torch_available, logging


if TYPE_CHECKING:
						if is_torch_available():
												import torch
						if is_tf_available():
												import tensorflow as tf

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_codegen import CodeGenTokenizer


A_    							=					logging.get_logger(__name__)

A_    							=					{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

A_    							=					{
    """vocab_file""": {
        """Salesforce/codegen-350M-mono""": """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """Salesforce/codegen-350M-mono""": """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """Salesforce/codegen-350M-mono""": (
            """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/tokenizer.json"""
        ),
    },
}

A_    							=					{
    """Salesforce/codegen-350M-mono""": 2048,
}




class  __lowerCamelCase  ( lowerCAmelCase			):
				a__:      List[str]          =    VOCAB_FILES_NAMES
				a__:      Any          =    PRETRAINED_VOCAB_FILES_MAP
				a__:      int          =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				a__:      Union[str, Any]          =    ['input_ids', 'attention_mask']
				a__:      List[str]          =    CodeGenTokenizer




				def __init__(				self							,						UpperCAmelCase=None							,						UpperCAmelCase=None							,						UpperCAmelCase=None							,						UpperCAmelCase="<|endoftext|>"							,						UpperCAmelCase="<|endoftext|>"							,						UpperCAmelCase="<|endoftext|>"							,						UpperCAmelCase=False							,						**UpperCAmelCase							,						):
							super().__init__(
							    UpperCAmelCase							,						UpperCAmelCase							,						tokenizer_file=UpperCAmelCase							,						unk_token=UpperCAmelCase							,						bos_token=UpperCAmelCase							,						eos_token=UpperCAmelCase							,						add_prefix_space=UpperCAmelCase							,						**UpperCAmelCase							,						)

							if kwargs.pop('''add_bos_token'''							,						UpperCAmelCase   ):
										lowerCamelCase_					=  kwargs.pop('''name_or_path'''							,						''''''   )
										raise ValueError(
										    '''Currenty GPT2\'s fast tokenizer does NOT support adding a BOS token.'''
										    '''Instead you should use GPT2\'s slow tokenizer class `CodeGenTokenizer` as follows: \n'''
										    f"`CodeGenTokenizer.from_pretrained('{model_id}')`\nor\n"
										    f"`AutoTokenizer.from_pretrained('{model_id}', use_fast=False)`\n"
										    '''This issue will be fixed soon, see: https://github.com/huggingface/tokenizers/pull/1005.'''
										    ''' so that the fast tokenizer works correctly.'''   )

							lowerCamelCase_					=  json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()   )
							if pre_tok_state.get('''add_prefix_space'''							,						UpperCAmelCase   ) != add_prefix_space:
										lowerCamelCase_					=  getattr(UpperCAmelCase							,						pre_tok_state.pop('''type'''   )   )
										lowerCamelCase_					=  add_prefix_space
										lowerCamelCase_					=  pre_tok_class(**UpperCAmelCase   )

							lowerCamelCase_					=  add_prefix_space




				def        UpperCAmelCase__						(				self							,						*UpperCAmelCase							,						**UpperCAmelCase   ):
							lowerCamelCase_					=  kwargs.get('''is_split_into_words'''							,						UpperCAmelCase   )
							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(*UpperCAmelCase							,						**UpperCAmelCase   )




				def        UpperCAmelCase__						(				self							,						*UpperCAmelCase							,						**UpperCAmelCase   ):
							lowerCamelCase_					=  kwargs.get('''is_split_into_words'''							,						UpperCAmelCase   )

							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(*UpperCAmelCase							,						**UpperCAmelCase   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase							,						UpperCAmelCase = None   ):
							lowerCamelCase_					=  self._tokenizer.model.save(UpperCAmelCase							,						name=UpperCAmelCase   )
							return tuple(UpperCAmelCase   )




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase							,						UpperCAmelCase = False							,						UpperCAmelCase = None							,						UpperCAmelCase = None							,						**UpperCAmelCase							,						):
							lowerCamelCase_					=  super().decode(
							    token_ids=UpperCAmelCase							,						skip_special_tokens=UpperCAmelCase							,						clean_up_tokenization_spaces=UpperCAmelCase							,						**UpperCAmelCase							,						)

							if truncate_before_pattern is not None and len(UpperCAmelCase   ) > 0:
										lowerCamelCase_					=  self.truncate(UpperCAmelCase							,						UpperCAmelCase   )

							return decoded_text





				def        UpperCAmelCase__						(				self							,						UpperCAmelCase							,						UpperCAmelCase   ):
							def find_re(UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase   ):
										lowerCamelCase_					=  pattern.search(UpperCAmelCase							,						UpperCAmelCase   )
										return m.start() if m else -1

							lowerCamelCase_					=  [re.compile(UpperCAmelCase							,						re.MULTILINE   ) for pattern in truncate_before_pattern]

							lowerCamelCase_					=  list(re.finditer('''^print'''							,						UpperCAmelCase							,						re.MULTILINE   )   )

							if len(UpperCAmelCase   ) > 1:
										lowerCamelCase_					=  completion[: prints[1].start()]

							lowerCamelCase_					=  list(re.finditer('''^def'''							,						UpperCAmelCase							,						re.MULTILINE   )   )

							if len(UpperCAmelCase   ) > 1:
										lowerCamelCase_					=  completion[: defs[1].start()]

							lowerCamelCase_					=  0

							lowerCamelCase_					=  [
							    pos for pos in [find_re(UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase   ) for terminal in terminals] if pos != -1
							]

							if len(UpperCAmelCase   ) > 0:
										return completion[: min(UpperCAmelCase   )]
							else:
										return completion




import copy
import os
from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union


if TYPE_CHECKING:
  from ...processing_utils import ProcessorMixin
  from ...utils import TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE			:						Dict				  =		logging.get_logger(__name__)

SCREAMING_SNAKE_CASE			:						Tuple				  =		{
    """google/owlvit-base-patch32""": """https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json""",
    """google/owlvit-base-patch16""": """https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json""",
    """google/owlvit-large-patch14""": """https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json""",
}
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      """owlvit_text_model"""

  def __init__(		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]=4_94_08  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=5_12  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=20_48  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]=12  ,				__SCREAMING_SNAKE_CASE			:   Tuple=8  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=16  ,				__SCREAMING_SNAKE_CASE			:   Tuple="quick_gelu"  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]=1E-5  ,				__SCREAMING_SNAKE_CASE			:   Any=0.0  ,				__SCREAMING_SNAKE_CASE			:   List[str]=0.02  ,				__SCREAMING_SNAKE_CASE			:   int=1.0  ,				__SCREAMING_SNAKE_CASE			:   int=0  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=4_94_06  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=4_94_07  ,				**__SCREAMING_SNAKE_CASE			:   Union[str, Any]  ,				):
   super().__init__(pad_token_id=__SCREAMING_SNAKE_CASE  ,				bos_token_id=__SCREAMING_SNAKE_CASE  ,				eos_token_id=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   __a							=	vocab_size
   __a							=	hidden_size
   __a							=	intermediate_size
   __a							=	num_hidden_layers
   __a							=	num_attention_heads
   __a							=	max_position_embeddings
   __a							=	hidden_act
   __a							=	layer_norm_eps
   __a							=	attention_dropout
   __a							=	initializer_range
   __a							=	initializer_factor

  @classmethod
  def 		_UpperCAmelCase (		cls			:   int  ,				__SCREAMING_SNAKE_CASE			:   Union[str, os.PathLike]  ,				**__SCREAMING_SNAKE_CASE			:   Optional[int]							):
   cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE							)

   __a							,  __a							=	cls.get_config_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   # get the text config dict if we are loading from OwlViTConfig
   if config_dict.get("model_type"							) == "owlvit":
    __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(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      """owlvit_vision_model"""

  def __init__(		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=7_68  ,				__SCREAMING_SNAKE_CASE			:   Any=30_72  ,				__SCREAMING_SNAKE_CASE			:   str=12  ,				__SCREAMING_SNAKE_CASE			:   int=12  ,				__SCREAMING_SNAKE_CASE			:   str=3  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=7_68  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=32  ,				__SCREAMING_SNAKE_CASE			:   Dict="quick_gelu"  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=1E-5  ,				__SCREAMING_SNAKE_CASE			:   int=0.0  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=0.02  ,				__SCREAMING_SNAKE_CASE			:   Dict=1.0  ,				**__SCREAMING_SNAKE_CASE			:   Optional[int]  ,				):
   super().__init__(**__SCREAMING_SNAKE_CASE							)

   __a							=	hidden_size
   __a							=	intermediate_size
   __a							=	num_hidden_layers
   __a							=	num_attention_heads
   __a							=	num_channels
   __a							=	image_size
   __a							=	patch_size
   __a							=	hidden_act
   __a							=	layer_norm_eps
   __a							=	attention_dropout
   __a							=	initializer_range
   __a							=	initializer_factor

  @classmethod
  def 		_UpperCAmelCase (		cls			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Union[str, os.PathLike]  ,				**__SCREAMING_SNAKE_CASE			:   Tuple							):
   cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE							)

   __a							,  __a							=	cls.get_config_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   # get the vision config dict if we are loading from OwlViTConfig
   if config_dict.get("model_type"							) == "owlvit":
    __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(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      """owlvit"""
  _SCREAMING_SNAKE_CASE     					=      True

  def __init__(		self			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]=None  ,				__SCREAMING_SNAKE_CASE			:   Tuple=None  ,				__SCREAMING_SNAKE_CASE			:   str=5_12  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=2.65_92  ,				__SCREAMING_SNAKE_CASE			:   Dict=True  ,				**__SCREAMING_SNAKE_CASE			:   List[Any]  ,				):
   super().__init__(**__SCREAMING_SNAKE_CASE							)

   if text_config is None:
    __a							=	{}
    logger.info("text_config is None. Initializing the OwlViTTextConfig with default values."							)

   if vision_config is None:
    __a							=	{}
    logger.info("vision_config is None. initializing the OwlViTVisionConfig with default values."							)

   __a							=	OwlViTTextConfig(**__SCREAMING_SNAKE_CASE							)
   __a							=	OwlViTVisionConfig(**__SCREAMING_SNAKE_CASE							)

   __a							=	projection_dim
   __a							=	logit_scale_init_value
   __a							=	return_dict
   __a							=	1.0

  @classmethod
  def 		_UpperCAmelCase (		cls			:   Tuple  ,				__SCREAMING_SNAKE_CASE			:   Union[str, os.PathLike]  ,				**__SCREAMING_SNAKE_CASE			:   List[str]							):
   cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE							)

   __a							,  __a							=	cls.get_config_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   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(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  @classmethod
  def 		_UpperCAmelCase (		cls			:   List[Any]  ,				__SCREAMING_SNAKE_CASE			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Dict  ,				**__SCREAMING_SNAKE_CASE			:   Optional[Any]							):
   __a							=	{}
   __a							=	text_config
   __a							=	vision_config

   return cls.from_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   Optional[Any]							):
   __a							=	copy.deepcopy(self.__dict__							)
   __a							=	self.text_config.to_dict()
   __a							=	self.vision_config.to_dict()
   __a							=	self.__class__.model_type
   return output
class  A_			(							a_			):

  @property
  def 		_UpperCAmelCase (		self			:   Any							):
   return OrderedDict(
       [
           ("input_ids", {0: "batch", 1: "sequence"}),
           ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
           ("attention_mask", {0: "batch", 1: "sequence"}),
       ]							)

  @property
  def 		_UpperCAmelCase (		self			:   Union[str, Any]							):
   return OrderedDict(
       [
           ("logits_per_image", {0: "batch"}),
           ("logits_per_text", {0: "batch"}),
           ("text_embeds", {0: "batch"}),
           ("image_embeds", {0: "batch"}),
       ]							)

  @property
  def 		_UpperCAmelCase (		self			:   str							):
   return 1E-4

  def 		_UpperCAmelCase (		self			:   Any  ,				__SCREAMING_SNAKE_CASE			:   "ProcessorMixin"  ,				__SCREAMING_SNAKE_CASE			:   int = -1  ,				__SCREAMING_SNAKE_CASE			:   int = -1  ,				__SCREAMING_SNAKE_CASE			:   Optional["TensorType"] = None  ,				):
   __a							=	super().generate_dummy_inputs(
       processor.tokenizer  ,				batch_size=__SCREAMING_SNAKE_CASE  ,				seq_length=__SCREAMING_SNAKE_CASE  ,				framework=__SCREAMING_SNAKE_CASE							)
   __a							=	super().generate_dummy_inputs(
       processor.image_processor  ,				batch_size=__SCREAMING_SNAKE_CASE  ,				framework=__SCREAMING_SNAKE_CASE							)
   return {**text_input_dict, **image_input_dict}

  @property
  def 		_UpperCAmelCase (		self			:   Optional[int]							):
   return 14


