





"""simple docstring"""



import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor






@require_tokenizers
@require_vision
class 		__snake_case (		unittest.TestCase					):





 """simple docstring"""


 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Optional[int]									=					tempfile.mkdtemp()

     # fmt: off
     __A   :						Union[str, Any]									=					['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
     # fmt: on
     __A   :						Dict									=					os.path.join(self.tmpdirname ,						VOCAB_FILES_NAMES['''vocab_file''']  )
     with open(self.vocab_file ,						'''w''' ,						encoding='''utf-8'''  ) as vocab_writer:
         vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]  )  )

     __A   :						Union[str, Any]									=					{
         '''do_resize''': True,
         '''size''': {'''height''': 18, '''width''': 18},
         '''do_normalize''': True,
         '''image_mean''': [0.5, 0.5, 0.5],
         '''image_std''': [0.5, 0.5, 0.5],
     }
     __A   :						Optional[int]									=					os.path.join(self.tmpdirname ,						__lowerCamelCase  )
     with open(self.image_processor_file ,						'''w''' ,						encoding='''utf-8'''  ) as fp:
         json.dump(__lowerCamelCase ,						__lowerCamelCase  )

 def  UpperCamelCase__(   self ,						**__lowerCamelCase  ):



     '''simple docstring'''




     return BertTokenizer.from_pretrained(self.tmpdirname ,						**__lowerCamelCase  )

 def  UpperCamelCase__(   self ,						**__lowerCamelCase  ):



     '''simple docstring'''




     return ViTImageProcessor.from_pretrained(self.tmpdirname ,						**__lowerCamelCase  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     shutil.rmtree(self.tmpdirname  )

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




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

     __A   :						Optional[Any]									=					[Image.fromarray(np.moveaxis(__lowerCamelCase ,						0 ,						-1  )  ) for x in image_inputs]

     return image_inputs

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						List[str]									=					self.get_tokenizer()
     __A   :						int									=					self.get_image_processor()

     __A   :						List[Any]									=					VisionTextDualEncoderProcessor(tokenizer=__lowerCamelCase ,						image_processor=__lowerCamelCase  )

     processor.save_pretrained(self.tmpdirname  )
     __A   :						List[Any]									=					VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname  )

     self.assertEqual(processor.tokenizer.get_vocab() ,						tokenizer.get_vocab()  )
     self.assertIsInstance(processor.tokenizer ,						(BertTokenizer, BertTokenizerFast)  )

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

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Tuple									=					VisionTextDualEncoderProcessor(
         tokenizer=self.get_tokenizer() ,						image_processor=self.get_image_processor()  )
     processor.save_pretrained(self.tmpdirname  )

     __A   :						Dict									=					self.get_tokenizer(bos_token='''(BOS)''' ,						eos_token='''(EOS)'''  )
     __A   :						Optional[Any]									=					self.get_image_processor(do_normalize=__lowerCamelCase ,						padding_value=1.0  )

     __A   :						Dict									=					VisionTextDualEncoderProcessor.from_pretrained(
         self.tmpdirname ,						bos_token='''(BOS)''' ,						eos_token='''(EOS)''' ,						do_normalize=__lowerCamelCase ,						padding_value=1.0  )

     self.assertEqual(processor.tokenizer.get_vocab() ,						tokenizer_add_kwargs.get_vocab()  )
     self.assertIsInstance(processor.tokenizer ,						(BertTokenizer, BertTokenizerFast)  )

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

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						List[Any]									=					self.get_image_processor()
     __A   :						Optional[Any]									=					self.get_tokenizer()

     __A   :						str									=					VisionTextDualEncoderProcessor(tokenizer=__lowerCamelCase ,						image_processor=__lowerCamelCase  )

     __A   :						Optional[Any]									=					self.prepare_image_inputs()

     __A   :						Dict									=					image_processor(__lowerCamelCase ,						return_tensors='''np'''  )
     __A   :						List[Any]									=					processor(images=__lowerCamelCase ,						return_tensors='''np'''  )

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

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						List[str]									=					self.get_image_processor()
     __A   :						Any									=					self.get_tokenizer()

     __A   :						Optional[int]									=					VisionTextDualEncoderProcessor(tokenizer=__lowerCamelCase ,						image_processor=__lowerCamelCase  )

     __A   :						Optional[int]									=					'''lower newer'''

     __A   :						List[str]									=					processor(text=__lowerCamelCase  )

     __A   :						Optional[Any]									=					tokenizer(__lowerCamelCase  )

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

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Optional[int]									=					self.get_image_processor()
     __A   :						Dict									=					self.get_tokenizer()

     __A   :						Union[str, Any]									=					VisionTextDualEncoderProcessor(tokenizer=__lowerCamelCase ,						image_processor=__lowerCamelCase  )

     __A   :						Any									=					'''lower newer'''
     __A   :						Tuple									=					self.prepare_image_inputs()

     __A   :						List[str]									=					processor(text=__lowerCamelCase ,						images=__lowerCamelCase  )

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

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

 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						str									=					self.get_image_processor()
     __A   :						Dict									=					self.get_tokenizer()

     __A   :						Any									=					VisionTextDualEncoderProcessor(tokenizer=__lowerCamelCase ,						image_processor=__lowerCamelCase  )

     __A   :						Dict									=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     __A   :						Optional[int]									=					processor.batch_decode(__lowerCamelCase  )
     __A   :						Optional[Any]									=					tokenizer.batch_decode(__lowerCamelCase  )

     self.assertListEqual(__lowerCamelCase ,						__lowerCamelCase  )







 def  UpperCamelCase__(   self  ):



     '''simple docstring'''




     __A   :						Any									=					self.get_image_processor()
     __A   :						str									=					self.get_tokenizer()

     __A   :						Optional[int]									=					VisionTextDualEncoderProcessor(tokenizer=__lowerCamelCase ,						image_processor=__lowerCamelCase  )

     __A   :						List[str]									=					'''lower newer'''
     __A   :						Tuple									=					self.prepare_image_inputs()

     __A   :						List[Any]									=					processor(text=__lowerCamelCase ,						images=__lowerCamelCase  )

     self.assertListEqual(list(inputs.keys()  ) ,						processor.model_input_names  )










"""simple docstring"""



# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


a_			=      {
    """configuration_vivit""": ["""VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """VivitConfig"""],
}
try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a_			=      ["""VivitImageProcessor"""]


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a_			=      [
           """VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """VivitModel""",
           """VivitPreTrainedModel""",
           """VivitForVideoClassification""",
       ]


if TYPE_CHECKING:
       from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .image_processing_vivit import VivitImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_vivit import (
                  VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  VivitForVideoClassification,
                  VivitModel,
                  VivitPreTrainedModel,
              )


else:
       import sys

       a_			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




