
"""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 CLIPImageProcessor, CLIPProcessor


@require_vision
class A_	(unittest.TestCase      ):




  '''simple docstring'''







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    tempfile.mkdtemp()

     # fmt: off
     UpperCAmelCase_					:					Union[str, Any]			     =    ["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
     UpperCAmelCase_					:					Tuple			     =    dict(zip(lowercase_				,   range(len(lowercase_  )  )  )  )
     UpperCAmelCase_					:					List[Any]			     =    ["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
     UpperCAmelCase_					:					int			     =    {"unk_token": "<unk>"}

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

     UpperCAmelCase_					:					List[Any]			     =    {
         "do_resize": True,
         "size": 20,
         "do_center_crop": True,
         "crop_size": 18,
         "do_normalize": True,
         "image_mean": [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
         "image_std": [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
     }
     UpperCAmelCase_					:					Tuple			     =    os.path.join(self.tmpdirname				,   lowercase_  )
     with open(self.image_processor_file				,   "w"				,   encoding="utf-8"  ) as fp:
        json.dump(lowercase_				,   lowercase_  )







  def        UpperCamelCase__					(		self				,   **lowercase_  ):

     """simple docstring"""
     return CLIPTokenizer.from_pretrained(self.tmpdirname				,   **lowercase_  )







  def        UpperCamelCase__					(		self				,   **lowercase_  ):

     """simple docstring"""
     return CLIPTokenizerFast.from_pretrained(self.tmpdirname				,   **lowercase_  )







  def        UpperCamelCase__					(		self				,   **lowercase_  ):

     """simple docstring"""
     return CLIPImageProcessor.from_pretrained(self.tmpdirname				,   **lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     shutil.rmtree(self.tmpdirname  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					int			     =    [np.random.randint(255				,   size=(3, 30, 400)				,   dtype=np.uinta  )]

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

     return image_inputs







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    self.get_tokenizer()
     UpperCAmelCase_					:					Tuple			     =    self.get_rust_tokenizer()
     UpperCAmelCase_					:					Tuple			     =    self.get_image_processor()

     UpperCAmelCase_					:					List[str]			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )
     processor_slow.save_pretrained(self.tmpdirname  )
     UpperCAmelCase_					:					Union[str, Any]			     =    CLIPProcessor.from_pretrained(self.tmpdirname				,   use_fast=lowercase_  )

     UpperCAmelCase_					:					int			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )
     processor_fast.save_pretrained(self.tmpdirname  )
     UpperCAmelCase_					:					Union[str, Any]			     =    CLIPProcessor.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				,   lowercase_  )
     self.assertIsInstance(processor_fast.tokenizer				,   lowercase_  )

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Tuple			     =    CLIPProcessor(tokenizer=self.get_tokenizer()				,   image_processor=self.get_image_processor()  )
     processor.save_pretrained(self.tmpdirname  )

     UpperCAmelCase_					:					int			     =    self.get_tokenizer(bos_token="(BOS)"				,   eos_token="(EOS)"  )
     UpperCAmelCase_					:					Union[str, Any]			     =    self.get_image_processor(do_normalize=lowercase_				,   padding_value=1.0  )

     UpperCAmelCase_					:					List[Any]			     =    CLIPProcessor.from_pretrained(
         self.tmpdirname				,   bos_token="(BOS)"				,   eos_token="(EOS)"				,   do_normalize=lowercase_				,   padding_value=1.0  )

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

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    self.get_image_processor()
     UpperCAmelCase_					:					str			     =    self.get_tokenizer()

     UpperCAmelCase_					:					List[Any]			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )

     UpperCAmelCase_					:					Union[str, Any]			     =    self.prepare_image_inputs()

     UpperCAmelCase_					:					int			     =    image_processor(lowercase_				,   return_tensors="np"  )
     UpperCAmelCase_					:					List[str]			     =    processor(images=lowercase_				,   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  ):

     """simple docstring"""
     UpperCAmelCase_					:					int			     =    self.get_image_processor()
     UpperCAmelCase_					:					str			     =    self.get_tokenizer()

     UpperCAmelCase_					:					int			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )

     UpperCAmelCase_					:					Any			     =    "lower newer"

     UpperCAmelCase_					:					Tuple			     =    processor(text=lowercase_  )

     UpperCAmelCase_					:					int			     =    tokenizer(lowercase_  )

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    self.get_image_processor()
     UpperCAmelCase_					:					Optional[Any]			     =    self.get_tokenizer()

     UpperCAmelCase_					:					Tuple			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )

     UpperCAmelCase_					:					Any			     =    "lower newer"
     UpperCAmelCase_					:					Tuple			     =    self.prepare_image_inputs()

     UpperCAmelCase_					:					List[Any]			     =    processor(text=lowercase_				,   images=lowercase_  )

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

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    self.get_image_processor()
     UpperCAmelCase_					:					List[str]			     =    self.get_tokenizer()

     UpperCAmelCase_					:					str			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )

     UpperCAmelCase_					:					Union[str, Any]			     =    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     UpperCAmelCase_					:					Dict			     =    processor.batch_decode(lowercase_  )
     UpperCAmelCase_					:					Tuple			     =    tokenizer.batch_decode(lowercase_  )

     self.assertListEqual(lowercase_				,   lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    self.get_image_processor()
     UpperCAmelCase_					:					Union[str, Any]			     =    self.get_tokenizer()

     UpperCAmelCase_					:					Any			     =    CLIPProcessor(tokenizer=lowercase_				,   image_processor=lowercase_  )

     UpperCAmelCase_					:					List[str]			     =    "lower newer"
     UpperCAmelCase_					:					List[Any]			     =    self.prepare_image_inputs()

     UpperCAmelCase_					:					Tuple			     =    processor(text=lowercase_				,   images=lowercase_  )

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







import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
						import torch

if is_vision_available():
						import PIL


_snake_case		=  logging.get_logger(__name__)






def 				A				(					_lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							def constraint_to_multiple_of(_lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase=0				, _lowerCamelCase=None  ):
														_lowerCAmelCase     :							Tuple    =    round(val / multiple  ) * multiple

														if max_val is not None and x > max_val:
																					_lowerCAmelCase     :							Optional[int]    =    math.floor(val / multiple  ) * multiple

														if x < min_val:
																					_lowerCAmelCase     :							List[str]    =    math.ceil(val / multiple  ) * multiple

														return x

							_lowerCAmelCase     :							Union[str, Any]    =    (output_size, output_size) if isinstance(_lowerCamelCase				, _lowerCamelCase  ) else output_size

							_lowerCAmelCase   ,    _lowerCAmelCase     :							Optional[Any]    =    get_image_size(_lowerCamelCase  )
							_lowerCAmelCase   ,    _lowerCAmelCase     :							Any    =    output_size

							# determine new height and width
							_lowerCAmelCase     :							List[Any]    =    output_height / input_height
							_lowerCAmelCase     :							Any    =    output_width / input_width

							if keep_aspect_ratio:
														# scale as little as possible
														if abs(1 - scale_width  ) < abs(1 - scale_height  ):
																					# fit width
																					_lowerCAmelCase     :							Union[str, Any]    =    scale_width
														else:
																					# fit height
																					_lowerCAmelCase     :							Union[str, Any]    =    scale_height

							_lowerCAmelCase     :							List[str]    =    constraint_to_multiple_of(scale_height * input_height				, multiple=_lowerCamelCase  )
							_lowerCAmelCase     :							Dict    =    constraint_to_multiple_of(scale_width * input_width				, multiple=_lowerCamelCase  )

							return (new_height, new_width)



class   UpperCAmelCase_    (       a):
							lowerCamelCase__   			=		['pixel_values']







							def __init__(   self,			__a = True,			__a = None,			__a = PILImageResampling.BILINEAR,			__a = False,			__a = 1,			__a = True,			__a = 1 / 255,			__a = True,			__a = None,			__a = None,			**__a,			):

														'''simple docstring'''

														super().__init__(**__a)
														_lowerCAmelCase     :							Any    =    size if size is not None else {"height": 384, "width": 384}
														_lowerCAmelCase     :							Optional[int]    =    get_size_dict(__a)
														_lowerCAmelCase     :							Optional[Any]    =    do_resize
														_lowerCAmelCase     :							Dict    =    size
														_lowerCAmelCase     :							Any    =    keep_aspect_ratio
														_lowerCAmelCase     :							str    =    ensure_multiple_of
														_lowerCAmelCase     :							str    =    resample
														_lowerCAmelCase     :							Dict    =    do_rescale
														_lowerCAmelCase     :							Optional[int]    =    rescale_factor
														_lowerCAmelCase     :							Dict    =    do_normalize
														_lowerCAmelCase     :							Dict    =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
														_lowerCAmelCase     :							int    =    image_std if image_std is not None else IMAGENET_STANDARD_STD







							def    snake_case__      (   self,			__a,			__a,			__a = False,			__a = 1,			__a = PILImageResampling.BICUBIC,			__a = None,			**__a,			):

														'''simple docstring'''

														_lowerCAmelCase     :							List[Any]    =    get_size_dict(__a)
														if "height" not in size or "width" not in size:
																					raise ValueError(f"The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}")
														_lowerCAmelCase     :							List[Any]    =    get_resize_output_image_size(
														    __a,			output_size=(size["height"], size["width"]),			keep_aspect_ratio=__a,			multiple=__a,			)
														return resize(__a,			size=__a,			resample=__a,			data_format=__a,			**__a)







							def    snake_case__      (   self,			__a,			__a,			__a = None,			**__a,			):

														'''simple docstring'''

														return rescale(__a,			scale=__a,			data_format=__a,			**__a)







							def    snake_case__      (   self,			__a,			__a,			__a,			__a = None,			**__a,			):

														'''simple docstring'''

														return normalize(__a,			mean=__a,			std=__a,			data_format=__a,			**__a)







							def    snake_case__      (   self,			__a,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = ChannelDimension.FIRST,			**__a,			):

														'''simple docstring'''

														_lowerCAmelCase     :							int    =    do_resize if do_resize is not None else self.do_resize
														_lowerCAmelCase     :							List[Any]    =    size if size is not None else self.size
														_lowerCAmelCase     :							str    =    get_size_dict(__a)
														_lowerCAmelCase     :							Dict    =    keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
														_lowerCAmelCase     :							Any    =    ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
														_lowerCAmelCase     :							int    =    resample if resample is not None else self.resample
														_lowerCAmelCase     :							Union[str, Any]    =    do_rescale if do_rescale is not None else self.do_rescale
														_lowerCAmelCase     :							Tuple    =    rescale_factor if rescale_factor is not None else self.rescale_factor
														_lowerCAmelCase     :							List[str]    =    do_normalize if do_normalize is not None else self.do_normalize
														_lowerCAmelCase     :							Dict    =    image_mean if image_mean is not None else self.image_mean
														_lowerCAmelCase     :							List[str]    =    image_std if image_std is not None else self.image_std

														_lowerCAmelCase     :							Optional[Any]    =    make_list_of_images(__a)

														if not valid_images(__a):
																					raise ValueError(
																					    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
																					    "torch.Tensor, tf.Tensor or jax.ndarray.")

														if do_resize and size is None or resample is None:
																					raise ValueError("Size and resample must be specified if do_resize is True.")

														if do_rescale and rescale_factor is None:
																					raise ValueError("Rescale factor must be specified if do_rescale is True.")

														if do_normalize and (image_mean is None or image_std is None):
																					raise ValueError("Image mean and std must be specified if do_normalize is True.")

														# All transformations expect numpy arrays.
														_lowerCAmelCase     :							List[Any]    =    [to_numpy_array(__a) for image in images]

														if do_resize:
																					_lowerCAmelCase     :							Any    =    [self.resize(image=__a,			size=__a,			resample=__a) for image in images]

														if do_rescale:
																					_lowerCAmelCase     :							List[str]    =    [self.rescale(image=__a,			scale=__a) for image in images]

														if do_normalize:
																					_lowerCAmelCase     :							Dict    =    [self.normalize(image=__a,			mean=__a,			std=__a) for image in images]

														_lowerCAmelCase     :							List[str]    =    [to_channel_dimension_format(__a,			__a) for image in images]

														_lowerCAmelCase     :							Optional[Any]    =    {"pixel_values": images}
														return BatchFeature(data=__a,			tensor_type=__a)







							def    snake_case__      (   self,			__a,			__a = None):

														'''simple docstring'''

														_lowerCAmelCase     :							Optional[Any]    =    outputs.logits

														# Resize logits and compute semantic segmentation maps
														if target_sizes is not None:
																					if len(__a) != len(__a):
																												raise ValueError(
																												    "Make sure that you pass in as many target sizes as the batch dimension of the logits")

																					if is_torch_tensor(__a):
																												_lowerCAmelCase     :							List[Any]    =    target_sizes.numpy()

																					_lowerCAmelCase     :							Dict    =    []

																					for idx in range(len(__a)):
																												_lowerCAmelCase     :							int    =    torch.nn.functional.interpolate(
																												    logits[idx].unsqueeze(dim=0),			size=target_sizes[idx],			mode="bilinear",			align_corners=__a)
																												_lowerCAmelCase     :							int    =    resized_logits[0].argmax(dim=0)
																												semantic_segmentation.append(__a)
														else:
																					_lowerCAmelCase     :							Dict    =    logits.argmax(dim=1)
																					_lowerCAmelCase     :							str    =    [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0])]

														return semantic_segmentation
