import unittest

from transformers import CamembertTokenizer, CamembertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


a_		       =   get_tests_dir("""fixtures/test_sentencepiece.model""")
a_		       =   get_tests_dir("""fixtures/test_sentencepiece_bpe.model""")

a_		       =   """pt""" if is_torch_available() else """tf"""


@require_sentencepiece
@require_tokenizers
class       UpperCAmelCase__     (		a_		,						unittest.TestCase       ):



  """simple docstring"""






  lowerCAmelCase__		:						List[str]     		=			CamembertTokenizer
  lowerCAmelCase__		:						Dict     		=			CamembertTokenizerFast
  lowerCAmelCase__		:						List[str]     		=			True
  lowerCAmelCase__		:						Optional[int]     		=			True






  def 						_UpperCAmelCase					(					self:      Optional[int] )			->			List[Any]:




    '''simple docstring'''




    super().setUp()

    # We have a SentencePiece fixture for testing
    __UpperCAmelCase         =							CamembertTokenizer(__SCREAMING_SNAKE_CASE )
    tokenizer.save_pretrained(self.tmpdirname )






  def 						_UpperCAmelCase					(					self:      Any )			->			Optional[int]:




    '''simple docstring'''




    __UpperCAmelCase         =							"<pad>"
    __UpperCAmelCase         =							1

    self.assertEqual(self.get_tokenizer()._convert_token_to_id(__SCREAMING_SNAKE_CASE )					,					__SCREAMING_SNAKE_CASE )
    self.assertEqual(self.get_tokenizer()._convert_id_to_token(__SCREAMING_SNAKE_CASE )					,					__SCREAMING_SNAKE_CASE )






  def 						_UpperCAmelCase					(					self:      Any )			->			Tuple:




    '''simple docstring'''




    __UpperCAmelCase         =							list(self.get_tokenizer().get_vocab().keys() )

    self.assertEqual(vocab_keys[0]					,					"<s>NOTUSED" )
    self.assertEqual(vocab_keys[1]					,					"<pad>" )
    self.assertEqual(vocab_keys[-1]					,					"<mask>" )
    self.assertEqual(len(__SCREAMING_SNAKE_CASE )					,					1_004 )






  def 						_UpperCAmelCase					(					self:      Optional[int] )			->			List[str]:




    '''simple docstring'''




    self.assertEqual(self.get_tokenizer().vocab_size					,					1_005 )






  def 						_UpperCAmelCase					(					self:      int )			->			int:




    '''simple docstring'''




    __UpperCAmelCase         =							CamembertTokenizer(__SCREAMING_SNAKE_CASE )
    tokenizer.save_pretrained(self.tmpdirname )
    __UpperCAmelCase         =							CamembertTokenizerFast.from_pretrained(self.tmpdirname )

    __UpperCAmelCase         =							"I was born in 92000, and this is falsé."

    __UpperCAmelCase         =							tokenizer.encode(__SCREAMING_SNAKE_CASE )
    __UpperCAmelCase         =							rust_tokenizer.encode(__SCREAMING_SNAKE_CASE )
    self.assertListEqual(__SCREAMING_SNAKE_CASE					,					__SCREAMING_SNAKE_CASE )

    __UpperCAmelCase         =							tokenizer.encode(__SCREAMING_SNAKE_CASE					,					add_special_tokens=__SCREAMING_SNAKE_CASE )
    __UpperCAmelCase         =							rust_tokenizer.encode(__SCREAMING_SNAKE_CASE					,					add_special_tokens=__SCREAMING_SNAKE_CASE )
    self.assertListEqual(__SCREAMING_SNAKE_CASE					,					__SCREAMING_SNAKE_CASE )

    # <unk> tokens are not the same for `rust` than for `slow`.
    # Because spm gives back raw token instead of `unk` in EncodeAsPieces
    # tokens = tokenizer.tokenize(sequence)
    __UpperCAmelCase         =							tokenizer.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE )
    __UpperCAmelCase         =							rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE )
    self.assertListEqual(__SCREAMING_SNAKE_CASE					,					__SCREAMING_SNAKE_CASE )






  def 						_UpperCAmelCase					(					self:      List[Any] )			->			int:




    '''simple docstring'''




    if not self.test_rust_tokenizer:
      return

    __UpperCAmelCase         =							self.get_tokenizer()
    __UpperCAmelCase         =							self.get_rust_tokenizer()

    __UpperCAmelCase         =							"I was born in 92000, and this is falsé."

    __UpperCAmelCase         =							tokenizer.tokenize(__SCREAMING_SNAKE_CASE )
    __UpperCAmelCase         =							rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE )
    self.assertListEqual(__SCREAMING_SNAKE_CASE					,					__SCREAMING_SNAKE_CASE )

    __UpperCAmelCase         =							tokenizer.encode(__SCREAMING_SNAKE_CASE					,					add_special_tokens=__SCREAMING_SNAKE_CASE )
    __UpperCAmelCase         =							rust_tokenizer.encode(__SCREAMING_SNAKE_CASE					,					add_special_tokens=__SCREAMING_SNAKE_CASE )
    self.assertListEqual(__SCREAMING_SNAKE_CASE					,					__SCREAMING_SNAKE_CASE )

    __UpperCAmelCase         =							self.get_rust_tokenizer()
    __UpperCAmelCase         =							tokenizer.encode(__SCREAMING_SNAKE_CASE )
    __UpperCAmelCase         =							rust_tokenizer.encode(__SCREAMING_SNAKE_CASE )
    self.assertListEqual(__SCREAMING_SNAKE_CASE					,					__SCREAMING_SNAKE_CASE )






  @slow
  def 						_UpperCAmelCase					(					self:      str )			->			List[Any]:




    '''simple docstring'''




    __UpperCAmelCase         =							{"input_ids": [[5, 54, 7_196, 297, 30, 23, 776, 18, 11, 3_215, 3_705, 8_252, 22, 3_164, 1_181, 2_116, 29, 16, 813, 25, 791, 3_314, 20, 3_446, 38, 27_575, 120, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 468, 17, 11, 9_088, 20, 1_517, 8, 22_804, 18_818, 10, 38, 629, 607, 607, 142, 19, 7_196, 867, 56, 10_326, 24, 2_267, 20, 416, 5_072, 15_612, 233, 734, 7, 2_399, 27, 16, 3_015, 1_649, 7, 24, 20, 4_338, 2_399, 27, 13, 3_400, 14, 13, 6_189, 8, 930, 9, 6]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
    # fmt: on

    # camembert is a french model. So we also use french texts.
    __UpperCAmelCase         =							[
        "Le transformeur est un modèle d'apprentissage profond introduit en 2017, "
        "utilisé principalement dans le domaine du traitement automatique des langues (TAL).",
        "À l'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus "
        "pour gérer des données séquentielles, telles que le langage naturel, pour des tâches "
        "telles que la traduction et la synthèse de texte.",
    ]

    self.tokenizer_integration_test_util(
        expected_encoding=__SCREAMING_SNAKE_CASE					,					model_name="camembert-base"					,					revision="3a0641d9a1aeb7e848a74299e7e4c4bca216b4cf"					,					sequences=__SCREAMING_SNAKE_CASE					,					)




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


