


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase		      = {'configuration_visual_bert': ['VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VisualBertConfig']}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase		      = [
     'VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'VisualBertForMultipleChoice',
     'VisualBertForPreTraining',
     'VisualBertForQuestionAnswering',
     'VisualBertForRegionToPhraseAlignment',
     'VisualBertForVisualReasoning',
     'VisualBertLayer',
     'VisualBertModel',
     'VisualBertPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_visual_bert import (
      VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      VisualBertForMultipleChoice,
      VisualBertForPreTraining,
      VisualBertForQuestionAnswering,
      VisualBertForRegionToPhraseAlignment,
      VisualBertForVisualReasoning,
      VisualBertLayer,
      VisualBertModel,
      VisualBertPreTrainedModel,
  )


else:
 import sys

 lowerCamelCase		      = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


lowerCamelCase		      = logging.get_logger(__name__)

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

lowerCamelCase		      = {
    'vocab_file': {
        'openai/clip-vit-base-patch32': 'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json',
    },
    'merges_file': {
        'openai/clip-vit-base-patch32': 'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt',
    },
    'tokenizer_file': {
        'openai/clip-vit-base-patch32': (
            'https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json'
        ),
    },
}

lowerCamelCase		      = {
    'openai/clip-vit-base-patch32': 77,
}




class A						(     UpperCamelCase_  ):
      UpperCamelCase__							:						Dict   =VOCAB_FILES_NAMES
      UpperCamelCase__							:						Optional[int]   =PRETRAINED_VOCAB_FILES_MAP
      UpperCamelCase__							:						Optional[int]   =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      UpperCamelCase__							:						Optional[Any]   =['input_ids', 'attention_mask']
      UpperCamelCase__							:						str   =CLIPTokenizer






      def __init__(      self		:  str    ,     lowercase_		:  Optional[Any]=None    ,     lowercase_		:  Optional[int]=None    ,     lowercase_		:  int=None    ,     lowercase_		:  Optional[int]="<|endoftext|>"    ,     lowercase_		:  Union[str, Any]="<|startoftext|>"    ,     lowercase_		:  Tuple="<|endoftext|>"    ,     lowercase_		:  int="<|endoftext|>"    ,     **lowercase_		:  Optional[Any]    ,     )      ->		Any:
             """simple docstring"""




             super().__init__(
                 lowercase_    ,     lowercase_    ,     tokenizer_file=lowercase_    ,     unk_token=lowercase_    ,     bos_token=lowercase_    ,     eos_token=lowercase_    ,     pad_token=lowercase_    ,     **lowercase_    ,     )

             if not isinstance(self.backend_tokenizer.pre_tokenizer    ,     pre_tokenizers.Sequence				):
                    raise ValueError(
                        'The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'
                        ' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'
                        ' to be compatible with this version.The easiest way to do so is'
                        ' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'
                        ' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'
                        ' transformers.'				)

             self._wrap_decode_method_backend_tokenizer()






      def  lowerCamelCase (      self		:  Any				)      ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase :	int						=self.backend_tokenizer.decode

             def new_decode_method(*lowercase_		:  List[str]    ,     **lowercase_		:  int				):
                    _lowerCamelCase :	Tuple						=orig_decode_method(*lowercase_    ,     **lowercase_				)
                    _lowerCamelCase :	Dict						=text.replace(self.backend_tokenizer.model.end_of_word_suffix    ,     ' '				).strip()
                    return text

             _lowerCamelCase :	List[Any]						=new_decode_method






      def  lowerCamelCase (      self		:  Dict    ,     lowercase_		:  List[int]    ,     lowercase_		:  Optional[List[int]] = None				)      ->		List[int]:
             """simple docstring"""




             _lowerCamelCase :	Union[str, Any]						=[self.bos_token_id]
             _lowerCamelCase :	str						=[self.eos_token_id]

             if token_ids_a is None:
                    return bos_token + token_ids_a + eos_token
             return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token






      def  lowerCamelCase (      self		:  Any    ,     lowercase_		:  List[int]    ,     lowercase_		:  Optional[List[int]] = None				)      ->		List[int]:
             """simple docstring"""




             _lowerCamelCase :	int						=[self.bos_token_id]
             _lowerCamelCase :	Any						=[self.eos_token_id]

             if token_ids_a is None:
                    return len(bos_token + token_ids_a + eos_token				) * [0]
             return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token				) * [0]






      def  lowerCamelCase (      self		:  str    ,     lowercase_		:  str    ,     lowercase_		:  Optional[str] = None				)      ->		Tuple[str]:
             """simple docstring"""




             _lowerCamelCase :	str						=self._tokenizer.model.save(lowercase_    ,     name=lowercase_				)
             return tuple(lowercase_				)


