




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





			def 							A (      self						:    Optional[Any]							):



						"""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.48145466, 0.4578275, 0.40821073],
						    "image_std": [0.26862954, 0.26130258, 0.27577711],
						}
						__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						:    Optional[Any]      ,		**a_						:    int							):



						"""simple docstring"""




						return CLIPTokenizer.from_pretrained(self.tmpdirname      ,		pad_token="!"      ,		**a_							)





			def 							A (      self						:    List[Any]      ,		**a_						:    str							):



						"""simple docstring"""




						return CLIPTokenizerFast.from_pretrained(self.tmpdirname      ,		pad_token="!"      ,		**a_							)





			def 							A (      self						:    Union[str, Any]      ,		**a_						:    int							):



						"""simple docstring"""




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





			def 							A (      self						:    Dict							):



						"""simple docstring"""




						shutil.rmtree(self.tmpdirname							)





			def 							A (      self						:    List[str]							):



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



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



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



						"""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						:    List[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						:    Optional[int]							):



						"""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						:    Optional[Any]							):



						"""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[Any]							):



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



						"""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			=		[
						    [49_406, 2_368, 49_407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
						    [49_406, 6_841, 11_301, 49_407, 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						:    Any							):



						"""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_							)











import operator as op


__UpperCamelCase   :			Optional[Any]          = "scaler.pt"
__UpperCamelCase   :			Optional[Any]          = "pytorch_model"
__UpperCamelCase   :			str          = "random_states"
__UpperCamelCase   :			Optional[int]          = "optimizer"
__UpperCamelCase   :			Optional[int]          = "scheduler"
__UpperCamelCase   :			str          = "pytorch_model.bin"
__UpperCamelCase   :			List[str]          = "pytorch_model.bin.index.json"
__UpperCamelCase   :			List[str]          = "model.safetensors"
__UpperCamelCase   :			Optional[int]          = "model.safetensors.index.json"
__UpperCamelCase   :			List[str]          = "1.10.2"
__UpperCamelCase   :			Dict          = "py38"
__UpperCamelCase   :			List[str]          = "4.17.0"
__UpperCamelCase   :			Any          = ["ml.p3.16xlarge", "ml.p3dn.24xlarge", "ml.p4dn.24xlarge"]
__UpperCamelCase   :			Any          = ["FULL_SHARD", "SHARD_GRAD_OP", "NO_SHARD", "HYBRID_SHARD", "HYBRID_SHARD_ZERO2"]
__UpperCamelCase   :			int          = ["TRANSFORMER_BASED_WRAP", "SIZE_BASED_WRAP", "NO_WRAP"]
__UpperCamelCase   :			Dict          = ["BACKWARD_PRE", "BACKWARD_POST", "NO_PREFETCH"]
__UpperCamelCase   :			str          = ["FULL_STATE_DICT", "LOCAL_STATE_DICT", "SHARDED_STATE_DICT"]
__UpperCamelCase   :			List[Any]          = "2.0.1"
__UpperCamelCase   :			int          = ["pdsh", "standard", "openmpi", "mvapich"]
__UpperCamelCase   :			List[str]          = ["default", "reduce-overhead", "max-autotune"]

__UpperCamelCase   :			List[Any]          = {">": op.gt, ">=": op.ge, "==": op.eq, "!=": op.ne, "<=": op.le, "<": op.lt}

# These are the args for `torch.distributed.launch` for pytorch < 1.9
__UpperCamelCase   :			List[Any]          = [
    "nnodes",
    "nproc_per_node",
    "rdzv_backend",
    "rdzv_endpoint",
    "rdzv_id",
    "rdzv_conf",
    "standalone",
    "max_restarts",
    "monitor_interval",
    "start_method",
    "role",
    "module",
    "m",
    "no_python",
    "run_path",
    "log_dir",
    "r",
    "redirects",
    "t",
    "tee",
    "node_rank",
    "master_addr",
    "master_port",
]

__UpperCamelCase   :			List[str]          = ["DEEPSPEED", "MULTI_GPU", "FSDP", "MEGATRON_LM"]
__UpperCamelCase   :			int          = ["DEEPSPEED", "MULTI_XPU", "FSDP"]

