





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 						SCREAMING_SNAKE_CASE__							(			unittest.TestCase    ):


      def   a					(self			: str ):





         """simple docstring"""



         __snake_case							=  tempfile.mkdtemp()

         # fmt: off
         __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
         __snake_case							=  dict(zip(SCREAMING_SNAKE_CASE_							,     range(len(SCREAMING_SNAKE_CASE_ ) ) ) )
         __snake_case							=  ['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', '']
         __snake_case							=  {'unk_token': '<unk>'}

         __snake_case							=  os.path.join(self.tmpdirname							,     VOCAB_FILES_NAMES['''vocab_file'''] )
         __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(SCREAMING_SNAKE_CASE_ ) + '''\n''' )
         with open(self.merges_file							,     '''w'''							,     encoding='''utf-8''' ) as fp:
            fp.write('''\n'''.join(SCREAMING_SNAKE_CASE_ ) )

         __snake_case							=  {
             'do_resize': True,
             'size': 20,
             'do_center_crop': True,
             'crop_size': 18,
             'do_normalize': True,
             'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
             'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
         }
         __snake_case							=  os.path.join(self.tmpdirname							,     SCREAMING_SNAKE_CASE_ )
         with open(self.image_processor_file							,     '''w'''							,     encoding='''utf-8''' ) as fp:
            json.dump(SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_ )


      def   a					(self			: Optional[int]							,     **a__			: Optional[Any] ):





         """simple docstring"""



         return CLIPTokenizer.from_pretrained(self.tmpdirname							,     pad_token='''!'''							,     **SCREAMING_SNAKE_CASE_ )


      def   a					(self			: str							,     **a__			: List[str] ):





         """simple docstring"""



         return CLIPTokenizerFast.from_pretrained(self.tmpdirname							,     pad_token='''!'''							,     **SCREAMING_SNAKE_CASE_ )


      def   a					(self			: Tuple							,     **a__			: Tuple ):





         """simple docstring"""



         return OwlViTImageProcessor.from_pretrained(self.tmpdirname							,     **SCREAMING_SNAKE_CASE_ )


      def   a					(self			: int ):





         """simple docstring"""



         shutil.rmtree(self.tmpdirname )


      def   a					(self			: Optional[int] ):





         """simple docstring"""



         __snake_case							=  [np.random.randint(255							,     size=(3, 30, 400)							,     dtype=np.uinta )]

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

         return image_inputs


      def   a					(self			: Union[str, Any] ):





         """simple docstring"""



         __snake_case							=  self.get_tokenizer()
         __snake_case							=  self.get_rust_tokenizer()
         __snake_case							=  self.get_image_processor()

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )
         processor_slow.save_pretrained(self.tmpdirname )
         __snake_case							=  OwlViTProcessor.from_pretrained(self.tmpdirname							,     use_fast=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )
         processor_fast.save_pretrained(self.tmpdirname )
         __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							,     SCREAMING_SNAKE_CASE_ )
         self.assertIsInstance(processor_fast.tokenizer							,     SCREAMING_SNAKE_CASE_ )

         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							,     SCREAMING_SNAKE_CASE_ )
         self.assertIsInstance(processor_fast.image_processor							,     SCREAMING_SNAKE_CASE_ )


      def   a					(self			: Optional[Any] ):





         """simple docstring"""



         __snake_case							=  OwlViTProcessor(tokenizer=self.get_tokenizer()							,     image_processor=self.get_image_processor() )
         processor.save_pretrained(self.tmpdirname )

         __snake_case							=  self.get_tokenizer(bos_token='''(BOS)'''							,     eos_token='''(EOS)''' )
         __snake_case							=  self.get_image_processor(do_normalize=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  OwlViTProcessor.from_pretrained(
             self.tmpdirname							,     bos_token='''(BOS)'''							,     eos_token='''(EOS)'''							,     do_normalize=SCREAMING_SNAKE_CASE_ )

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

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


      def   a					(self			: Union[str, Any] ):





         """simple docstring"""



         __snake_case							=  self.get_image_processor()
         __snake_case							=  self.get_tokenizer()

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  self.prepare_image_inputs()

         __snake_case							=  image_processor(SCREAMING_SNAKE_CASE_							,     return_tensors='''np''' )
         __snake_case							=  processor(images=SCREAMING_SNAKE_CASE_							,     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   a					(self			: Union[str, Any] ):





         """simple docstring"""



         __snake_case							=  self.get_image_processor()
         __snake_case							=  self.get_tokenizer()

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  'lower newer'

         __snake_case							=  processor(text=SCREAMING_SNAKE_CASE_							,     return_tensors='''np''' )

         __snake_case							=  tokenizer(SCREAMING_SNAKE_CASE_							,     return_tensors='''np''' )

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


      def   a					(self			: List[str] ):





         """simple docstring"""



         __snake_case							=  self.get_image_processor()
         __snake_case							=  self.get_tokenizer()

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )

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

         __snake_case							=  processor(text=SCREAMING_SNAKE_CASE_							,     images=SCREAMING_SNAKE_CASE_ )

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

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


      def   a					(self			: List[str] ):





         """simple docstring"""



         __snake_case							=  'google/owlvit-base-patch32'
         __snake_case							=  OwlViTProcessor.from_pretrained(SCREAMING_SNAKE_CASE_ )

         __snake_case							=  ['cat', 'nasa badge']
         __snake_case							=  processor(text=SCREAMING_SNAKE_CASE_ )

         __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(SCREAMING_SNAKE_CASE_ ):
            processor()


      def   a					(self			: Tuple ):





         """simple docstring"""



         __snake_case							=  'google/owlvit-base-patch32'
         __snake_case							=  OwlViTProcessor.from_pretrained(SCREAMING_SNAKE_CASE_ )

         __snake_case							=  [['cat', 'nasa badge'], ['person']]
         __snake_case							=  processor(text=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  16
         __snake_case							=  len(SCREAMING_SNAKE_CASE_ )
         __snake_case							=  max([len(SCREAMING_SNAKE_CASE_ ) 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(SCREAMING_SNAKE_CASE_ ):
            processor()


      def   a					(self			: str ):





         """simple docstring"""



         __snake_case							=  'google/owlvit-base-patch32'
         __snake_case							=  OwlViTProcessor.from_pretrained(SCREAMING_SNAKE_CASE_ )

         __snake_case							=  ['cat', 'nasa badge']
         __snake_case							=  processor(text=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  16
         __snake_case							=  inputs['input_ids']
         __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   a					(self			: Union[str, Any] ):





         """simple docstring"""



         __snake_case							=  self.get_image_processor()
         __snake_case							=  self.get_tokenizer()

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )

         __snake_case							=  self.prepare_image_inputs()
         __snake_case							=  self.prepare_image_inputs()

         __snake_case							=  processor(images=SCREAMING_SNAKE_CASE_							,     query_images=SCREAMING_SNAKE_CASE_ )

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

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


      def   a					(self			: List[Any] ):





         """simple docstring"""



         __snake_case							=  self.get_image_processor()
         __snake_case							=  self.get_tokenizer()

         __snake_case							=  OwlViTProcessor(tokenizer=SCREAMING_SNAKE_CASE_							,     image_processor=SCREAMING_SNAKE_CASE_ )

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

         __snake_case							=  processor.batch_decode(SCREAMING_SNAKE_CASE_ )
         __snake_case							=  tokenizer.batch_decode(SCREAMING_SNAKE_CASE_ )

         self.assertListEqual(SCREAMING_SNAKE_CASE_							,     SCREAMING_SNAKE_CASE_ )





'''simple docstring'''



import argparse


A__						:   Optional[Any]				=    """docs/source/_static/js/custom.js"""



def      UpperCAmelCase__   (      UpperCAmelCase_       :							Optional[int]				)	->						int:
     with open(UpperCAmelCase_ ,       encoding='utf-8' ,       newline='\n'				) as f:
          __lowerCamelCase  :      Dict														=						f.readlines()
     __lowerCamelCase  :      Tuple														=						0

     # First let's put the right version
     while not lines[index].startswith('const stableVersion ='				):
          index += 1
     __lowerCamelCase  :      Dict														=						F'const stableVersion = "v{version}"\n'

     # Then update the dictionary
     while not lines[index].startswith('const versionMapping = {'				):
          index += 1

     # We go until the end
     while not lines[index].startswith('}'				):
          index += 1
     # We add the new version at the end
     lines[index - 1] += F'    "v{version}": "v{version}",\n'

     with open(UpperCAmelCase_ ,       'w' ,       encoding='utf-8' ,       newline='\n'				) as f:
          f.writelines(UpperCAmelCase_				)


if __name__ == "__main__":
      A__						:   str				=    argparse.ArgumentParser()
      parser.add_argument("""--version""", help="""Release version.""")
      A__						:   Any				=    parser.parse_args()
      update_custom_js(args.version)






