






import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import OwlViTImageProcessor, OwlViTProcessor






@require_vision
class 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  def 				lowercase_		(							self						:		int )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   tempfile.mkdtemp()

       # fmt: off
       SCREAMING_SNAKE_CASE__   =   ['''''', '''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>''']
       # fmt: on
       SCREAMING_SNAKE_CASE__   =   dict(zip(__lowerCamelCase     ,       range(len(__lowerCamelCase ) ) ) )
       SCREAMING_SNAKE_CASE__   =   ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', '''''']
       SCREAMING_SNAKE_CASE__   =   {'''unk_token''': '''<unk>'''}

       SCREAMING_SNAKE_CASE__   =   os.path.join(self.tmpdirname     ,       VOCAB_FILES_NAMES['''vocab_file'''] )
       SCREAMING_SNAKE_CASE__   =   os.path.join(self.tmpdirname     ,       VOCAB_FILES_NAMES['''merges_file'''] )
       with open(self.vocab_file     ,       '''w'''     ,       encoding='''utf-8''' ) as fp:
            fp.write(json.dumps(__lowerCamelCase ) + '''\n''' )
       with open(self.merges_file     ,       '''w'''     ,       encoding='''utf-8''' ) as fp:
            fp.write('''\n'''.join(__lowerCamelCase ) )

       SCREAMING_SNAKE_CASE__   =   {
           '''do_resize''': True,
           '''size''': 20,
           '''do_center_crop''': True,
           '''crop_size''': 18,
           '''do_normalize''': True,
           '''image_mean''': [0.48145466, 0.4578275, 0.40821073],
           '''image_std''': [0.26862954, 0.26130258, 0.27577711],
       }
       SCREAMING_SNAKE_CASE__   =   os.path.join(self.tmpdirname     ,       __lowerCamelCase )
       with open(self.image_processor_file     ,       '''w'''     ,       encoding='''utf-8''' ) as fp:
            json.dump(__lowerCamelCase     ,       __lowerCamelCase )






  def 				lowercase_		(							self						:		Tuple     ,       **__lowerCamelCase						:		Optional[int] )		->							List[str]:
       return CLIPTokenizer.from_pretrained(self.tmpdirname     ,       pad_token='''!'''     ,       **__lowerCamelCase )






  def 				lowercase_		(							self						:		List[str]     ,       **__lowerCamelCase						:		Any )		->							List[Any]:
       return CLIPTokenizerFast.from_pretrained(self.tmpdirname     ,       pad_token='''!'''     ,       **__lowerCamelCase )






  def 				lowercase_		(							self						:		Optional[int]     ,       **__lowerCamelCase						:		List[str] )		->							Any:
       return OwlViTImageProcessor.from_pretrained(self.tmpdirname     ,       **__lowerCamelCase )






  def 				lowercase_		(							self						:		List[Any] )		->							int:
       shutil.rmtree(self.tmpdirname )






  def 				lowercase_		(							self						:		Optional[Any] )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   [np.random.randint(255     ,       size=(3, 30, 400)     ,       dtype=np.uinta )]

       SCREAMING_SNAKE_CASE__   =   [Image.fromarray(np.moveaxis(__lowerCamelCase     ,       0     ,       -1 ) ) for x in image_inputs]

       return image_inputs






  def 				lowercase_		(							self						:		Dict )		->							str:
       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer()
       SCREAMING_SNAKE_CASE__   =   self.get_rust_tokenizer()
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor()

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )
       processor_slow.save_pretrained(self.tmpdirname )
       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor.from_pretrained(self.tmpdirname     ,       use_fast=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )
       processor_fast.save_pretrained(self.tmpdirname )
       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor.from_pretrained(self.tmpdirname )

       self.assertEqual(processor_slow.tokenizer.get_vocab()     ,       tokenizer_slow.get_vocab() )
       self.assertEqual(processor_fast.tokenizer.get_vocab()     ,       tokenizer_fast.get_vocab() )
       self.assertEqual(tokenizer_slow.get_vocab()     ,       tokenizer_fast.get_vocab() )
       self.assertIsInstance(processor_slow.tokenizer     ,       __lowerCamelCase )
       self.assertIsInstance(processor_fast.tokenizer     ,       __lowerCamelCase )

       self.assertEqual(processor_slow.image_processor.to_json_string()     ,       image_processor.to_json_string() )
       self.assertEqual(processor_fast.image_processor.to_json_string()     ,       image_processor.to_json_string() )
       self.assertIsInstance(processor_slow.image_processor     ,       __lowerCamelCase )
       self.assertIsInstance(processor_fast.image_processor     ,       __lowerCamelCase )






  def 				lowercase_		(							self						:		Union[str, Any] )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=self.get_tokenizer()     ,       image_processor=self.get_image_processor() )
       processor.save_pretrained(self.tmpdirname )

       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer(bos_token='''(BOS)'''     ,       eos_token='''(EOS)''' )
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor(do_normalize=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor.from_pretrained(
           self.tmpdirname     ,       bos_token='''(BOS)'''     ,       eos_token='''(EOS)'''     ,       do_normalize=__lowerCamelCase )

       self.assertEqual(processor.tokenizer.get_vocab()     ,       tokenizer_add_kwargs.get_vocab() )
       self.assertIsInstance(processor.tokenizer     ,       __lowerCamelCase )

       self.assertEqual(processor.image_processor.to_json_string()     ,       image_processor_add_kwargs.to_json_string() )
       self.assertIsInstance(processor.image_processor     ,       __lowerCamelCase )






  def 				lowercase_		(							self						:		Tuple )		->							str:
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor()
       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer()

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   self.prepare_image_inputs()

       SCREAMING_SNAKE_CASE__   =   image_processor(__lowerCamelCase     ,       return_tensors='''np''' )
       SCREAMING_SNAKE_CASE__   =   processor(images=__lowerCamelCase     ,       return_tensors='''np''' )

       for key in input_image_proc.keys():
            self.assertAlmostEqual(input_image_proc[key].sum()     ,       input_processor[key].sum()     ,       delta=1e-2 )






  def 				lowercase_		(							self						:		List[str] )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor()
       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer()

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   '''lower newer'''

       SCREAMING_SNAKE_CASE__   =   processor(text=__lowerCamelCase     ,       return_tensors='''np''' )

       SCREAMING_SNAKE_CASE__   =   tokenizer(__lowerCamelCase     ,       return_tensors='''np''' )

       for key in encoded_tok.keys():
            self.assertListEqual(encoded_tok[key][0].tolist()     ,       encoded_processor[key][0].tolist() )






  def 				lowercase_		(							self						:		Optional[int] )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor()
       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer()

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   '''lower newer'''
       SCREAMING_SNAKE_CASE__   =   self.prepare_image_inputs()

       SCREAMING_SNAKE_CASE__   =   processor(text=__lowerCamelCase     ,       images=__lowerCamelCase )

       self.assertListEqual(list(inputs.keys() )     ,       ['''input_ids''', '''attention_mask''', '''pixel_values'''] )

       # test if it raises when no input is passed
       with pytest.raises(__lowerCamelCase ):
            processor()






  def 				lowercase_		(							self						:		int )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   '''google/owlvit-base-patch32'''
       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor.from_pretrained(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   ['''cat''', '''nasa badge''']
       SCREAMING_SNAKE_CASE__   =   processor(text=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   16
       self.assertListEqual(list(inputs.keys() )     ,       ['''input_ids''', '''attention_mask'''] )
       self.assertEqual(inputs['''input_ids'''].shape     ,       (2, seq_length) )

       # test if it raises when no input is passed
       with pytest.raises(__lowerCamelCase ):
            processor()






  def 				lowercase_		(							self						:		Optional[int] )		->							Tuple:
       SCREAMING_SNAKE_CASE__   =   '''google/owlvit-base-patch32'''
       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor.from_pretrained(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   [['''cat''', '''nasa badge'''], ['''person''']]
       SCREAMING_SNAKE_CASE__   =   processor(text=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   16
       SCREAMING_SNAKE_CASE__   =   len(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   max([len(__lowerCamelCase ) for texts in input_texts] )

       self.assertListEqual(list(inputs.keys() )     ,       ['''input_ids''', '''attention_mask'''] )
       self.assertEqual(inputs['''input_ids'''].shape     ,       (batch_size * num_max_text_queries, seq_length) )

       # test if it raises when no input is passed
       with pytest.raises(__lowerCamelCase ):
            processor()






  def 				lowercase_		(							self						:		Tuple )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   '''google/owlvit-base-patch32'''
       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor.from_pretrained(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   ['''cat''', '''nasa badge''']
       SCREAMING_SNAKE_CASE__   =   processor(text=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   16
       SCREAMING_SNAKE_CASE__   =   inputs['''input_ids''']
       SCREAMING_SNAKE_CASE__   =   [
           [4_9406, 2368, 4_9407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
           [4_9406, 6841, 1_1301, 4_9407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       ]

       self.assertListEqual(list(inputs.keys() )     ,       ['''input_ids''', '''attention_mask'''] )
       self.assertEqual(inputs['''input_ids'''].shape     ,       (2, seq_length) )
       self.assertListEqual(list(input_ids[0] )     ,       predicted_ids[0] )
       self.assertListEqual(list(input_ids[1] )     ,       predicted_ids[1] )






  def 				lowercase_		(							self						:		Optional[int] )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor()
       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer()

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   self.prepare_image_inputs()
       SCREAMING_SNAKE_CASE__   =   self.prepare_image_inputs()

       SCREAMING_SNAKE_CASE__   =   processor(images=__lowerCamelCase     ,       query_images=__lowerCamelCase )

       self.assertListEqual(list(inputs.keys() )     ,       ['''query_pixel_values''', '''pixel_values'''] )

       # test if it raises when no input is passed
       with pytest.raises(__lowerCamelCase ):
            processor()







  def 				lowercase_		(							self						:		str )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   self.get_image_processor()
       SCREAMING_SNAKE_CASE__   =   self.get_tokenizer()

       SCREAMING_SNAKE_CASE__   =   OwlViTProcessor(tokenizer=__lowerCamelCase     ,       image_processor=__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       SCREAMING_SNAKE_CASE__   =   processor.batch_decode(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   tokenizer.batch_decode(__lowerCamelCase )

       self.assertListEqual(__lowerCamelCase     ,       __lowerCamelCase )





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


_SCREAMING_SNAKE_CASE					:  List[str]             =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:  Tuple             =      {
    '''transfo-xl-wt103''': '''https://huggingface.co/transfo-xl-wt103/resolve/main/config.json''',
}






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= "transfo-xl"
  a									= ["mems"]
  a									= {
      "n_token": "vocab_size",
      "hidden_size": "d_model",
      "num_attention_heads": "n_head",
      "num_hidden_layers": "n_layer",
  }






  def __init__(							self						:		Any     ,       __lowerCamelCase						:		int=26_7735     ,       __lowerCamelCase						:		Any=[2_0000, 4_0000, 20_0000]     ,       __lowerCamelCase						:		Dict=1024     ,       __lowerCamelCase						:		Optional[int]=1024     ,       __lowerCamelCase						:		List[Any]=16     ,       __lowerCamelCase						:		Union[str, Any]=64     ,       __lowerCamelCase						:		Dict=4096     ,       __lowerCamelCase						:		int=4     ,       __lowerCamelCase						:		Dict=False     ,       __lowerCamelCase						:		Tuple=18     ,       __lowerCamelCase						:		Optional[int]=1600     ,       __lowerCamelCase						:		str=1000     ,       __lowerCamelCase						:		Any=True     ,       __lowerCamelCase						:		Dict=True     ,       __lowerCamelCase						:		List[Any]=0     ,       __lowerCamelCase						:		int=-1     ,       __lowerCamelCase						:		Tuple=True     ,       __lowerCamelCase						:		List[Any]=0.1     ,       __lowerCamelCase						:		int=0.0     ,       __lowerCamelCase						:		int=True     ,       __lowerCamelCase						:		str="normal"     ,       __lowerCamelCase						:		List[str]=0.01     ,       __lowerCamelCase						:		Any=0.01     ,       __lowerCamelCase						:		List[str]=0.02     ,       __lowerCamelCase						:		List[str]=1e-5     ,       __lowerCamelCase						:		Union[str, Any]=0     ,       **__lowerCamelCase						:		int     ,       )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   vocab_size
       SCREAMING_SNAKE_CASE__   =   []
       self.cutoffs.extend(__lowerCamelCase )
       if proj_share_all_but_first:
            SCREAMING_SNAKE_CASE__   =   [False] + [True] * len(self.cutoffs )
       else:
            SCREAMING_SNAKE_CASE__   =   [False] + [False] * len(self.cutoffs )
       SCREAMING_SNAKE_CASE__   =   d_model
       SCREAMING_SNAKE_CASE__   =   d_embed
       SCREAMING_SNAKE_CASE__   =   d_head
       SCREAMING_SNAKE_CASE__   =   d_inner
       SCREAMING_SNAKE_CASE__   =   div_val
       SCREAMING_SNAKE_CASE__   =   pre_lnorm
       SCREAMING_SNAKE_CASE__   =   n_layer
       SCREAMING_SNAKE_CASE__   =   n_head
       SCREAMING_SNAKE_CASE__   =   mem_len
       SCREAMING_SNAKE_CASE__   =   same_length
       SCREAMING_SNAKE_CASE__   =   attn_type
       SCREAMING_SNAKE_CASE__   =   clamp_len
       SCREAMING_SNAKE_CASE__   =   sample_softmax
       SCREAMING_SNAKE_CASE__   =   adaptive
       SCREAMING_SNAKE_CASE__   =   dropout
       SCREAMING_SNAKE_CASE__   =   dropatt
       SCREAMING_SNAKE_CASE__   =   untie_r
       SCREAMING_SNAKE_CASE__   =   init
       SCREAMING_SNAKE_CASE__   =   init_range
       SCREAMING_SNAKE_CASE__   =   proj_init_std
       SCREAMING_SNAKE_CASE__   =   init_std
       SCREAMING_SNAKE_CASE__   =   layer_norm_epsilon
       super().__init__(eos_token_id=__lowerCamelCase     ,       **__lowerCamelCase )






  @property
  def 				lowercase_		(							self						:		str )		->							Dict:
       # Message copied from Transformer-XL documentation
       logger.info(f'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )
       return -1







  @max_position_embeddings.setter
  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		Any )		->							List[Any]:
       # Message copied from Transformer-XL documentation
       raise NotImplementedError(
           f'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )


