





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	:				Tuple				):





         """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(a__    ,      range(len(a__				)				)				)				)
         __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(a__				) + '''\n'''				)
         with open(self.merges_file    ,      '''w'''    ,      encoding='''utf-8'''				) as fp:
            fp.write('''\n'''.join(a__				)				)

         __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    ,      a__				)
         with open(self.image_processor_file    ,      '''w'''    ,      encoding='''utf-8'''				) as fp:
            json.dump(a__    ,      a__				)


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





         """simple docstring"""



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


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





         """simple docstring"""



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


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





         """simple docstring"""



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


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         shutil.rmtree(self.tmpdirname				)


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





         """simple docstring"""



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

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

         return image_inputs


      def        a			(self	:				List[Any]				):





         """simple docstring"""



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

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

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

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


      def        a			(self	:				List[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=a__				)

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

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

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


      def        a			(self	:				Tuple				):





         """simple docstring"""



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

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

         __snake_case								=       self.prepare_image_inputs()

         __snake_case								=       image_processor(a__    ,      return_tensors='''np'''				)
         __snake_case								=       processor(images=a__    ,      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	:				Any				):





         """simple docstring"""



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

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

         __snake_case								=       '''lower newer'''

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

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

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


      def        a			(self	:				Any				):





         """simple docstring"""



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

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

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

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

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

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


      def        a			(self	:				str				):





         """simple docstring"""



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

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

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


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



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

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

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


      def        a			(self	:				int				):





         """simple docstring"""



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

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

         __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	:				int				):





         """simple docstring"""



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

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

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

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

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

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


      def        a			(self	:				Optional[Any]				):





         """simple docstring"""



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

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

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

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

         self.assertListEqual(a__    ,      a__				)








# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
    import torch

class 		SCREAMING_SNAKE_CASE__    (	TensorFormatter[Mapping, 'torch.Tensor', Mapping]  ):


      def __init__(self	:				Optional[int]    ,      a__	:				Tuple=None    ,      **a__	:				Optional[int]				):





         """simple docstring"""



         super().__init__(features=a__				)
         __snake_case								=       torch_tensor_kwargs
         import torch  # noqa import torch at initialization


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





         """simple docstring"""



         import torch

         if isinstance(a__    ,      a__				) and column:
            if all(
                isinstance(a__    ,      torch.Tensor				) and x.shape == column[0].shape and x.dtype == column[0].dtype
                for x in column				):
               return torch.stack(a__				)
         return column


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





         """simple docstring"""



         import torch

         if isinstance(a__    ,      (str, bytes, type(a__				))				):
            return value
         elif isinstance(a__    ,      (np.character, np.ndarray)				) and np.issubdtype(value.dtype    ,      np.character				):
            return value.tolist()

         __snake_case								=       {}

         if isinstance(a__    ,      (np.number, np.ndarray)				) and np.issubdtype(value.dtype    ,      np.integer				):
            __snake_case								=       {'''dtype''': torch.intaa}
         elif isinstance(a__    ,      (np.number, np.ndarray)				) and np.issubdtype(value.dtype    ,      np.floating				):
            __snake_case								=       {'''dtype''': torch.floataa}
         elif config.PIL_AVAILABLE and "PIL" in sys.modules:
            import PIL.Image

            if isinstance(a__    ,      PIL.Image.Image				):
               __snake_case								=       np.asarray(a__				)
         return torch.tensor(a__    ,      **{**default_dtype, **self.torch_tensor_kwargs}				)


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





         """simple docstring"""



         import torch

         # support for torch, tf, jax etc.
         if hasattr(a__    ,      '''__array__'''				) and not isinstance(a__    ,      torch.Tensor				):
            __snake_case								=       data_struct.__array__()
         # support for nested types like struct of list of struct
         if isinstance(a__    ,      np.ndarray				):
            if data_struct.dtype == object:  # torch tensors cannot be instantied from an array of objects
               return self._consolidate([self.recursive_tensorize(a__				) for substruct in data_struct]				)
         elif isinstance(a__    ,      (list, tuple)				):
            return self._consolidate([self.recursive_tensorize(a__				) for substruct in data_struct]				)
         return self._tensorize(a__				)


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





         """simple docstring"""



         return map_nested(self._recursive_tensorize    ,      a__    ,      map_list=a__				)


      def        a			(self	:				Optional[int]    ,      a__	:				pa.Table				):





         """simple docstring"""



         __snake_case								=       self.numpy_arrow_extractor().extract_row(a__				)
         __snake_case								=       self.python_features_decoder.decode_row(a__				)
         return self.recursive_tensorize(a__				)


      def        a			(self	:				List[Any]    ,      a__	:				pa.Table				):





         """simple docstring"""



         __snake_case								=       self.numpy_arrow_extractor().extract_column(a__				)
         __snake_case								=       self.python_features_decoder.decode_column(a__    ,      pa_table.column_names[0]				)
         __snake_case								=       self.recursive_tensorize(a__				)
         __snake_case								=       self._consolidate(a__				)
         return column


      def        a			(self	:				Optional[int]    ,      a__	:				pa.Table				):





         """simple docstring"""



         __snake_case								=       self.numpy_arrow_extractor().extract_batch(a__				)
         __snake_case								=       self.python_features_decoder.decode_batch(a__				)
         __snake_case								=       self.recursive_tensorize(a__				)
         for column_name in batch:
            __snake_case								=       self._consolidate(batch[column_name]				)
         return batch

