


'''simple docstring'''




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





     def 							__UpperCAmelCase      ( self       :      List[Any]    )				->  List[Any]:
        lowerCAmelCase     =			tempfile.mkdtemp()

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

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

        lowerCAmelCase     =			{
            'do_resize': True,
            'size': 2_0,
            'do_center_crop': True,
            'crop_size': 1_8,
            'do_normalize': True,
            'image_mean': [0.48_145_466, 0.4_578_275, 0.40_821_073],
            'image_std': [0.26_862_954, 0.26_130_258, 0.27_577_711],
        }
        lowerCAmelCase     =			os.path.join(self.tmpdirname    ,      UpperCAmelCase__    )
        with open(self.image_processor_file    ,      'w'    ,      encoding='utf-8'    ) as fp:
           json.dump(UpperCAmelCase__    ,      UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      str    ,      **UpperCAmelCase__       :      Tuple    )				->  Optional[Any]:
        return CLIPTokenizer.from_pretrained(self.tmpdirname    ,      pad_token='!'    ,      **UpperCAmelCase__    )





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





     def 							__UpperCAmelCase      ( self       :      int    ,      **UpperCAmelCase__       :      Optional[int]    )				->  Any:
        return OwlViTImageProcessor.from_pretrained(self.tmpdirname    ,      **UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      str    )				->  Optional[Any]:
        shutil.rmtree(self.tmpdirname    )





     def 							__UpperCAmelCase      ( self       :      List[str]    )				->  Tuple:
        lowerCAmelCase     =			[np.random.randint(2_5_5    ,      size=(3, 3_0, 4_0_0)    ,      dtype=np.uinta    )]

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

        return image_inputs





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Any:
        lowerCAmelCase     =			self.get_tokenizer()
        lowerCAmelCase     =			self.get_rust_tokenizer()
        lowerCAmelCase     =			self.get_image_processor()

        lowerCAmelCase     =			OwlViTProcessor(tokenizer=UpperCAmelCase__    ,      image_processor=UpperCAmelCase__    )
        processor_slow.save_pretrained(self.tmpdirname    )
        lowerCAmelCase     =			OwlViTProcessor.from_pretrained(self.tmpdirname    ,      use_fast=UpperCAmelCase__    )

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

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





     def 							__UpperCAmelCase      ( self       :      int    )				->  List[str]:
        lowerCAmelCase     =			OwlViTProcessor(tokenizer=self.get_tokenizer()    ,      image_processor=self.get_image_processor()    )
        processor.save_pretrained(self.tmpdirname    )

        lowerCAmelCase     =			self.get_tokenizer(bos_token='(BOS)'    ,      eos_token='(EOS)'    )
        lowerCAmelCase     =			self.get_image_processor(do_normalize=UpperCAmelCase__    )

        lowerCAmelCase     =			OwlViTProcessor.from_pretrained(
            self.tmpdirname    ,      bos_token='(BOS)'    ,      eos_token='(EOS)'    ,      do_normalize=UpperCAmelCase__    )

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

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





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  str:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			OwlViTProcessor(tokenizer=UpperCAmelCase__    ,      image_processor=UpperCAmelCase__    )

        lowerCAmelCase     =			self.prepare_image_inputs()

        lowerCAmelCase     =			image_processor(UpperCAmelCase__    ,      return_tensors='np'    )
        lowerCAmelCase     =			processor(images=UpperCAmelCase__    ,      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 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  Union[str, Any]:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			OwlViTProcessor(tokenizer=UpperCAmelCase__    ,      image_processor=UpperCAmelCase__    )

        lowerCAmelCase     =			'lower newer'

        lowerCAmelCase     =			processor(text=UpperCAmelCase__    ,      return_tensors='np'    )

        lowerCAmelCase     =			tokenizer(UpperCAmelCase__    ,      return_tensors='np'    )

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





     def 							__UpperCAmelCase      ( self       :      int    )				->  Dict:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			OwlViTProcessor(tokenizer=UpperCAmelCase__    ,      image_processor=UpperCAmelCase__    )

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

        lowerCAmelCase     =			processor(text=UpperCAmelCase__    ,      images=UpperCAmelCase__    )

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

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





     def 							__UpperCAmelCase      ( self       :      str    )				->  Dict:
        lowerCAmelCase     =			'google/owlvit-base-patch32'
        lowerCAmelCase     =			OwlViTProcessor.from_pretrained(UpperCAmelCase__    )

        lowerCAmelCase     =			['cat', 'nasa badge']
        lowerCAmelCase     =			processor(text=UpperCAmelCase__    )

        lowerCAmelCase     =			1_6
        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(UpperCAmelCase__    ):
           processor()





     def 							__UpperCAmelCase      ( self       :      Any    )				->  Dict:
        lowerCAmelCase     =			'google/owlvit-base-patch32'
        lowerCAmelCase     =			OwlViTProcessor.from_pretrained(UpperCAmelCase__    )

        lowerCAmelCase     =			[['cat', 'nasa badge'], ['person']]
        lowerCAmelCase     =			processor(text=UpperCAmelCase__    )

        lowerCAmelCase     =			1_6
        lowerCAmelCase     =			len(UpperCAmelCase__    )
        lowerCAmelCase     =			max([len(UpperCAmelCase__    ) 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(UpperCAmelCase__    ):
           processor()





     def 							__UpperCAmelCase      ( self       :      Any    )				->  Any:
        lowerCAmelCase     =			'google/owlvit-base-patch32'
        lowerCAmelCase     =			OwlViTProcessor.from_pretrained(UpperCAmelCase__    )

        lowerCAmelCase     =			['cat', 'nasa badge']
        lowerCAmelCase     =			processor(text=UpperCAmelCase__    )

        lowerCAmelCase     =			1_6
        lowerCAmelCase     =			inputs['input_ids']
        lowerCAmelCase     =			[
            [4_9_4_0_6, 2_3_6_8, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [4_9_4_0_6, 6_8_4_1, 1_1_3_0_1, 4_9_4_0_7, 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 							__UpperCAmelCase      ( self       :      int    )				->  Any:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			OwlViTProcessor(tokenizer=UpperCAmelCase__    ,      image_processor=UpperCAmelCase__    )

        lowerCAmelCase     =			self.prepare_image_inputs()
        lowerCAmelCase     =			self.prepare_image_inputs()

        lowerCAmelCase     =			processor(images=UpperCAmelCase__    ,      query_images=UpperCAmelCase__    )

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

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





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  Tuple:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			OwlViTProcessor(tokenizer=UpperCAmelCase__    ,      image_processor=UpperCAmelCase__    )

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

        lowerCAmelCase     =			processor.batch_decode(UpperCAmelCase__    )
        lowerCAmelCase     =			tokenizer.batch_decode(UpperCAmelCase__    )

        self.assertListEqual(UpperCAmelCase__    ,      UpperCAmelCase__    )









'''simple docstring'''




import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu

@require_cpu
class 		UpperCAmelCase_      (  unittest.TestCase		):





     def 							__UpperCAmelCase      ( self       :      str    )				->  List[Any]:
        lowerCAmelCase     =			torch.nn.Linear(1_0    ,      1_0    )
        lowerCAmelCase     =			torch.optim.SGD(model.parameters()    ,      0.1    )
        lowerCAmelCase     =			Accelerator()
        lowerCAmelCase     =			accelerator.prepare(UpperCAmelCase__    )
        try:
           pickle.loads(pickle.dumps(UpperCAmelCase__    )    )
        except Exception as e:
           self.fail(F'''Accelerated optimizer pickling failed with {e}'''    )
        AcceleratorState._reset_state()





