


import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class     __UpperCAmelCase							(       __A ,					unittest.TestCase							):


     """simple docstring"""
     _lowerCamelCase   =      CLIPTokenizer
     _lowerCamelCase   =      CLIPTokenizerFast
     _lowerCamelCase   =      True
     _lowerCamelCase   =      {}
     _lowerCamelCase   =      False


     def 	snake_case_  (	self    ):
        super().setUp()

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

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


     def 	snake_case_  (	self  ,       **__A    ):
        kwargs.update(self.special_tokens_map    )
        return CLIPTokenizer.from_pretrained(self.tmpdirname  ,       **lowerCamelCase__    )


     def 	snake_case_  (	self  ,       **__A    ):
        kwargs.update(self.special_tokens_map    )
        return CLIPTokenizerFast.from_pretrained(self.tmpdirname  ,       **lowerCamelCase__    )


     def 	snake_case_  (	self  ,       __A    ):
        __a					=  """lower newer"""
        __a					=  """lower newer"""
        return input_text, output_text


     def 	snake_case_  (	self    ):
        __a					=  CLIPTokenizer(self.vocab_file  ,       self.merges_file  ,       **self.special_tokens_map    )
        __a					=  """lower newer"""
        __a					=  ["""lo""", """w""", """er</w>""", """n""", """e""", """w""", """er</w>"""]
        __a					=  tokenizer.tokenize(lowerCamelCase__    )
        self.assertListEqual(lowerCamelCase__  ,       lowerCamelCase__    )

        __a					=  tokens + [tokenizer.unk_token]
        __a					=  [10, 2, 16, 9, 3, 2, 16, 20]
        self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__    )  ,       lowerCamelCase__    )


     @require_ftfy
     def 	snake_case_  (	self    ):
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
              __a					=  self.tokenizer_class.from_pretrained(lowerCamelCase__  ,       **lowerCamelCase__    )
              __a					=  self.rust_tokenizer_class.from_pretrained(lowerCamelCase__  ,       **lowerCamelCase__    )

              __a					=  """A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d."""
              __a					=  tokenizer_s.tokenize(lowerCamelCase__    )
              __a					=  tokenizer_r.tokenize(lowerCamelCase__    )

              self.assertListEqual(lowerCamelCase__  ,       lowerCamelCase__    )

              # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
              # with Tilde) encoded in 2 different ways
              __a					=  """xa\u0303y""" + """ """ + """x\xe3y"""
              __a					=  tokenizer_s.tokenize(lowerCamelCase__    )
              __a					=  tokenizer_r.tokenize(lowerCamelCase__    )

              self.assertListEqual(lowerCamelCase__  ,       lowerCamelCase__    )

              # Test that the tokenization is identical on unicode of space type
              __a					=  [
                  """\u0009""",  # (horizontal tab, '\t')
                  """\u000B""",  # (vertical tab)
                  """\u000C""",  # (form feed)
                  """\u0020""",  # (space, ' ')
                  """\u200E""",  # (left-to-right mark):w
                  """\u200F""",  # (right-to-left mark)
              ]
              for unicode_seq in spaces_unicodes:
                 __a					=  tokenizer_s.tokenize(lowerCamelCase__    )
                 __a					=  tokenizer_r.tokenize(lowerCamelCase__    )

                 self.assertListEqual(lowerCamelCase__  ,       lowerCamelCase__    )

              # Test that the tokenization is identical on unicode of line break type
              __a					=  [
                  """\u000A""",  # (line feed, '\n')
                  """\r\n""",  # (carriage return and line feed, '\r\n')
                  """\u000D""",  # (carriage return, '\r')
                  """\r""",  # (carriage return, '\r')
                  """\u000D""",  # (carriage return, '\r')
                  """\u2028""",  # (line separator)
                  """\u2029""",  # (paragraph separator)
                  # "\u0085", # (next line)
              ]

              # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
              # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
              # space (and thus into an empty list).

              for unicode_seq in line_break_unicodes:
                 __a					=  tokenizer_s.tokenize(lowerCamelCase__    )
                 __a					=  tokenizer_r.tokenize(lowerCamelCase__    )

                 self.assertListEqual(lowerCamelCase__  ,       lowerCamelCase__    )


     def 	snake_case_  (	self    ):
        # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
              __a					=  """hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
              __a					=  f'''{text_of_1_token} {text_of_1_token}'''

              __a					=  self.rust_tokenizer_class.from_pretrained(
                  lowerCamelCase__  ,       use_fast=lowerCamelCase__  ,       )
              __a					=  tokenizer_r(lowerCamelCase__  ,       return_offsets_mapping=lowerCamelCase__  ,       add_special_tokens=lowerCamelCase__    )
              self.assertEqual(encoding.offset_mapping[0]  ,       (0, len(lowerCamelCase__    ))    )
              self.assertEqual(
                  encoding.offset_mapping[1]  ,       (len(lowerCamelCase__    ) + 1, len(lowerCamelCase__    ) + 1 + len(lowerCamelCase__    ))  ,       )

              __a					=  f''' {text}'''

              __a					=  self.rust_tokenizer_class.from_pretrained(
                  lowerCamelCase__  ,       use_fast=lowerCamelCase__  ,       )
              __a					=  tokenizer_r(lowerCamelCase__  ,       return_offsets_mapping=lowerCamelCase__  ,       add_special_tokens=lowerCamelCase__    )
              self.assertEqual(encoding.offset_mapping[0]  ,       (1, 1 + len(lowerCamelCase__    ))    )
              self.assertEqual(
                  encoding.offset_mapping[1]  ,       (1 + len(lowerCamelCase__    ) + 1, 1 + len(lowerCamelCase__    ) + 1 + len(lowerCamelCase__    ))  ,       )


     def 	snake_case_  (	self    ):
        # Test related to the breaking change introduced in transformers v4.17.0
        # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
        with self.assertRaises(lowerCamelCase__    ) as context:
           self.rust_tokenizer_class.from_pretrained("""robot-test/old-clip-tokenizer"""    )

        self.assertTrue(
            context.exception.args[0].startswith(
                """The `backend_tokenizer` provided does not match the expected format."""    )    )


     @require_ftfy
     def 	snake_case_  (	self    ):
        super().test_tokenization_python_rust_equals()


     def 	snake_case_  (	self    ):
        pass









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

import numpy as np

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


if is_torch_available():
					import torch


__A								=       logging.get_logger(__name__)







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			snake_case_  						=			['''pixel_values''']


			def __init__( self     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = PILImageResampling.BILINEAR     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = 1 / 255     ,		lowerCamelCase__ = True     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> None:



							'''simple docstring'''
							super().__init__(**lowerCamelCase__				)
							__lowerCamelCase									=       size if size is not None else {'shortest_edge': 256}
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		default_to_square=lowerCamelCase__				)
							__lowerCamelCase									=       crop_size if crop_size is not None else {'height': 224, 'width': 224}
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		param_name='crop_size'				)
							__lowerCamelCase									=       do_resize
							__lowerCamelCase									=       size
							__lowerCamelCase									=       resample
							__lowerCamelCase									=       do_center_crop
							__lowerCamelCase									=       crop_size
							__lowerCamelCase									=       do_rescale
							__lowerCamelCase									=       rescale_factor
							__lowerCamelCase									=       do_normalize
							__lowerCamelCase									=       image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
							__lowerCamelCase									=       image_std if image_std is not None else IMAGENET_STANDARD_STD


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = PILImageResampling.BICUBIC     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		default_to_square=lowerCamelCase__				)
							if "shortest_edge" not in size:
											raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""				)
							__lowerCamelCase									=       get_resize_output_image_size(lowerCamelCase__     ,		size=size['shortest_edge']     ,		default_to_square=lowerCamelCase__				)
							return resize(lowerCamelCase__     ,		size=lowerCamelCase__     ,		resample=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__				)
							if "height" not in size or "width" not in size:
											raise ValueError(f"""The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}"""				)
							return center_crop(lowerCamelCase__     ,		size=(size['height'], size['width'])     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__				)       -> np.ndarray:



							'''simple docstring'''
							return rescale(lowerCamelCase__     ,		scale=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		**lowerCamelCase__     ,		)       -> np.ndarray:



							'''simple docstring'''
							return normalize(lowerCamelCase__     ,		mean=lowerCamelCase__     ,		std=lowerCamelCase__     ,		data_format=lowerCamelCase__     ,		**lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = None     ,		lowerCamelCase__ = ChannelDimension.FIRST     ,		**lowerCamelCase__     ,		)       -> str:



							'''simple docstring'''
							__lowerCamelCase									=       do_resize if do_resize is not None else self.do_resize
							__lowerCamelCase									=       size if size is not None else self.size
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		default_to_square=lowerCamelCase__				)
							__lowerCamelCase									=       resample if resample is not None else self.resample
							__lowerCamelCase									=       do_center_crop if do_center_crop is not None else self.do_center_crop
							__lowerCamelCase									=       crop_size if crop_size is not None else self.crop_size
							__lowerCamelCase									=       get_size_dict(lowerCamelCase__     ,		param_name='crop_size'				)
							__lowerCamelCase									=       do_rescale if do_rescale is not None else self.do_rescale
							__lowerCamelCase									=       rescale_factor if rescale_factor is not None else self.rescale_factor
							__lowerCamelCase									=       do_normalize if do_normalize is not None else self.do_normalize
							__lowerCamelCase									=       image_mean if image_mean is not None else self.image_mean
							__lowerCamelCase									=       image_std if image_std is not None else self.image_std

							__lowerCamelCase									=       make_list_of_images(lowerCamelCase__				)

							if not valid_images(lowerCamelCase__				):
											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:
											raise ValueError('Size must be specified if do_resize is True.'				)

							if do_center_crop and crop_size is None:
											raise ValueError('Crop size must be specified if do_center_crop 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									=       [to_numpy_array(lowerCamelCase__				) for image in images]

							if do_resize:
											__lowerCamelCase									=       [self.resize(image=lowerCamelCase__     ,		size=lowerCamelCase__     ,		resample=lowerCamelCase__				) for image in images]

							if do_center_crop:
											__lowerCamelCase									=       [self.center_crop(image=lowerCamelCase__     ,		size=lowerCamelCase__				) for image in images]

							if do_rescale:
											__lowerCamelCase									=       [self.rescale(image=lowerCamelCase__     ,		scale=lowerCamelCase__				) for image in images]

							if do_normalize:
											__lowerCamelCase									=       [self.normalize(image=lowerCamelCase__     ,		mean=lowerCamelCase__     ,		std=lowerCamelCase__				) for image in images]

							__lowerCamelCase									=       [to_channel_dimension_format(lowerCamelCase__     ,		lowerCamelCase__				) for image in images]

							__lowerCamelCase									=       {'pixel_values': images}
							return BatchFeature(data=lowerCamelCase__     ,		tensor_type=lowerCamelCase__				)






			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__ = None				)       -> Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       outputs.logits

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

											if is_torch_tensor(lowerCamelCase__				):
															__lowerCamelCase									=       target_sizes.numpy()

											__lowerCamelCase									=       []

											for idx in range(len(lowerCamelCase__				)				):
															__lowerCamelCase									=       torch.nn.functional.interpolate(
															    logits[idx].unsqueeze(dim=0				)     ,		size=target_sizes[idx]     ,		mode='bilinear'     ,		align_corners=lowerCamelCase__				)
															__lowerCamelCase									=       resized_logits[0].argmax(dim=0				)
															semantic_segmentation.append(lowerCamelCase__				)
							else:
											__lowerCamelCase									=       logits.argmax(dim=1				)
											__lowerCamelCase									=       [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]				)]

							return semantic_segmentation


