


"""simple docstring"""

import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer
from ...utils import logging


UpperCAmelCase__  							=logging.get_logger(__name__)

UpperCAmelCase__  							="▁"

UpperCAmelCase__  							={"vocab_file": "sentencepiece.bpe.model"}

UpperCAmelCase__  							={
    "vocab_file": {
        "facebook/nllb-200-distilled-600M": (
            "https://huggingface.co/facebook/nllb-200-distilled-600M/blob/main/sentencepiece.bpe.model"
        ),
    }
}

UpperCAmelCase__  							={
    "facebook/nllb-200-distilled-600M": 1024,
}

# fmt: off
UpperCAmelCase__  							=["ace_Arab", "ace_Latn", "acm_Arab", "acq_Arab", "aeb_Arab", "afr_Latn", "ajp_Arab", "aka_Latn", "amh_Ethi", "apc_Arab", "arb_Arab", "ars_Arab", "ary_Arab", "arz_Arab", "asm_Beng", "ast_Latn", "awa_Deva", "ayr_Latn", "azb_Arab", "azj_Latn", "bak_Cyrl", "bam_Latn", "ban_Latn", "bel_Cyrl", "bem_Latn", "ben_Beng", "bho_Deva", "bjn_Arab", "bjn_Latn", "bod_Tibt", "bos_Latn", "bug_Latn", "bul_Cyrl", "cat_Latn", "ceb_Latn", "ces_Latn", "cjk_Latn", "ckb_Arab", "crh_Latn", "cym_Latn", "dan_Latn", "deu_Latn", "dik_Latn", "dyu_Latn", "dzo_Tibt", "ell_Grek", "eng_Latn", "epo_Latn", "est_Latn", "eus_Latn", "ewe_Latn", "fao_Latn", "pes_Arab", "fij_Latn", "fin_Latn", "fon_Latn", "fra_Latn", "fur_Latn", "fuv_Latn", "gla_Latn", "gle_Latn", "glg_Latn", "grn_Latn", "guj_Gujr", "hat_Latn", "hau_Latn", "heb_Hebr", "hin_Deva", "hne_Deva", "hrv_Latn", "hun_Latn", "hye_Armn", "ibo_Latn", "ilo_Latn", "ind_Latn", "isl_Latn", "ita_Latn", "jav_Latn", "jpn_Jpan", "kab_Latn", "kac_Latn", "kam_Latn", "kan_Knda", "kas_Arab", "kas_Deva", "kat_Geor", "knc_Arab", "knc_Latn", "kaz_Cyrl", "kbp_Latn", "kea_Latn", "khm_Khmr", "kik_Latn", "kin_Latn", "kir_Cyrl", "kmb_Latn", "kon_Latn", "kor_Hang", "kmr_Latn", "lao_Laoo", "lvs_Latn", "lij_Latn", "lim_Latn", "lin_Latn", "lit_Latn", "lmo_Latn", "ltg_Latn", "ltz_Latn", "lua_Latn", "lug_Latn", "luo_Latn", "lus_Latn", "mag_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "min_Latn", "mkd_Cyrl", "plt_Latn", "mlt_Latn", "mni_Beng", "khk_Cyrl", "mos_Latn", "mri_Latn", "zsm_Latn", "mya_Mymr", "nld_Latn", "nno_Latn", "nob_Latn", "npi_Deva", "nso_Latn", "nus_Latn", "nya_Latn", "oci_Latn", "gaz_Latn", "ory_Orya", "pag_Latn", "pan_Guru", "pap_Latn", "pol_Latn", "por_Latn", "prs_Arab", "pbt_Arab", "quy_Latn", "ron_Latn", "run_Latn", "rus_Cyrl", "sag_Latn", "san_Deva", "sat_Beng", "scn_Latn", "shn_Mymr", "sin_Sinh", "slk_Latn", "slv_Latn", "smo_Latn", "sna_Latn", "snd_Arab", "som_Latn", "sot_Latn", "spa_Latn", "als_Latn", "srd_Latn", "srp_Cyrl", "ssw_Latn", "sun_Latn", "swe_Latn", "swh_Latn", "szl_Latn", "tam_Taml", "tat_Cyrl", "tel_Telu", "tgk_Cyrl", "tgl_Latn", "tha_Thai", "tir_Ethi", "taq_Latn", "taq_Tfng", "tpi_Latn", "tsn_Latn", "tso_Latn", "tuk_Latn", "tum_Latn", "tur_Latn", "twi_Latn", "tzm_Tfng", "uig_Arab", "ukr_Cyrl", "umb_Latn", "urd_Arab", "uzn_Latn", "vec_Latn", "vie_Latn", "war_Latn", "wol_Latn", "xho_Latn", "ydd_Hebr", "yor_Latn", "yue_Hant", "zho_Hans", "zho_Hant", "zul_Latn"]





class    lowerCamelCase__						(		_a    ):
						a :     Tuple											=		VOCAB_FILES_NAMES
						a :     Dict											=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						a :     List[Any]											=		PRETRAINED_VOCAB_FILES_MAP
						a :     List[str]											=		["""input_ids""", """attention_mask"""]

						a :     List[int]											=		[]
						a :     List[int]											=		[]
						def __init__(		self	:	List[str]      ,       A_	:	Optional[int]      ,       A_	:	Optional[int]="<s>"      ,       A_	:	str="</s>"      ,       A_	:	Union[str, Any]="</s>"      ,       A_	:	List[str]="<s>"      ,       A_	:	List[Any]="<unk>"      ,       A_	:	Union[str, Any]="<pad>"      ,       A_	:	int="<mask>"      ,       A_	:	Any=None      ,       A_	:	Optional[int]=None      ,       A_	:	int=None      ,       A_	:	Optional[Dict[str, Any]] = None      ,       A_	:	Any=None      ,       A_	:	Union[str, Any]=False      ,       **A_	:	Tuple      ,       ):






							'''simple docstring'''


							__lowercase									=	AddedToken(A_      ,       lstrip=A_      ,       rstrip=A_							) if isinstance(A_      ,       A_							) else mask_token

							__lowercase									=	{} if sp_model_kwargs is None else sp_model_kwargs
							__lowercase									=	legacy_behaviour

							super().__init__(
							    bos_token=A_      ,       eos_token=A_      ,       unk_token=A_      ,       sep_token=A_      ,       cls_token=A_      ,       pad_token=A_      ,       mask_token=A_      ,       tokenizer_file=A_      ,       src_lang=A_      ,       tgt_lang=A_      ,       additional_special_tokens=A_      ,       sp_model_kwargs=self.sp_model_kwargs      ,       legacy_behaviour=A_      ,       **A_      ,       )

							__lowercase									=	spm.SentencePieceProcessor(**self.sp_model_kwargs							)
							self.sp_model.Load(str(A_							)							)
							__lowercase									=	vocab_file
							# Original fairseq vocab and spm vocab must be "aligned":
							# Vocab    |    0    |    1    |   2    |    3    |  4   |  5   |  6   |   7  |   8  |  9
							# -------- | ------- | ------- | ------ | ------- | ---- | ---- | ---- | ---- | ---- | ----
							# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a'
							# spm      | '<unk>' | '<s>'   | '</s>' | 'an'    | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' | '▁s'

							# Mimic fairseq token-to-id alignment for the first 4 token
							__lowercase									=	{"""<s>""": 0, """<pad>""": 1, """</s>""": 2, """<unk>""": 3}

							# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
							__lowercase									=	1

							__lowercase									=	len(self.sp_model							)
							__lowercase									=	{
							    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(A_							)
							}
							__lowercase									=	{v: k for k, v in self.lang_code_to_id.items()}
							__lowercase									=	len(self.sp_model							) + len(self.lang_code_to_id							) + self.fairseq_offset

							self.fairseq_tokens_to_ids.update(self.lang_code_to_id							)
							__lowercase									=	{v: k for k, v in self.fairseq_tokens_to_ids.items()}
							__lowercase									=	list(self.lang_code_to_id.keys()							)

							if additional_special_tokens is not None:
								# Only add those special tokens if they are not already there.
								self._additional_special_tokens.extend(
								    [t for t in additional_special_tokens if t not in self._additional_special_tokens]							)

							__lowercase									=	src_lang if src_lang is not None else """eng_Latn"""
							__lowercase									=	self.lang_code_to_id[self._src_lang]
							__lowercase									=	tgt_lang
							self.set_src_lang_special_tokens(self._src_lang							)
						def __getstate__(		self	:	Optional[Any]							):






							'''simple docstring'''


							__lowercase									=	self.__dict__.copy()
							__lowercase									=	None
							__lowercase									=	self.sp_model.serialized_model_proto()
							return state
						def __setstate__(		self	:	Optional[Any]      ,       A_	:	Optional[Any]							):






							'''simple docstring'''


							__lowercase									=	d

							# for backward compatibility
							if not hasattr(self      ,       """sp_model_kwargs"""							):
								__lowercase									=	{}

							__lowercase									=	spm.SentencePieceProcessor(**self.sp_model_kwargs							)
							self.sp_model.LoadFromSerializedProto(self.sp_model_proto							)
						@property
						def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






							'''simple docstring'''


							return len(self.sp_model							) + len(self.lang_code_to_id							) + self.fairseq_offset + 1  # Plus 1 for the mask token
						@property
						def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






							'''simple docstring'''


							return self._src_lang
						@src_lang.setter
						def SCREAMING_SNAKE_CASE_	(		self	:	str      ,       A_	:	str							):






							'''simple docstring'''


							__lowercase									=	new_src_lang
							self.set_src_lang_special_tokens(self._src_lang							)
						def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]      ,       A_	:	List[int]      ,       A_	:	Optional[List[int]] = None      ,       A_	:	bool = False							):






							'''simple docstring'''


							if already_has_special_tokens:
								return super().get_special_tokens_mask(
								    token_ids_a=A_      ,       token_ids_a=A_      ,       already_has_special_tokens=A_							)

							__lowercase									=	[1] * len(self.prefix_tokens							)
							__lowercase									=	[1] * len(self.suffix_tokens							)
							if token_ids_a is None:
								return prefix_ones + ([0] * len(A_							)) + suffix_ones
							return prefix_ones + ([0] * len(A_							)) + ([0] * len(A_							)) + suffix_ones
						def SCREAMING_SNAKE_CASE_	(		self	:	Any      ,       A_	:	List[int]      ,       A_	:	Optional[List[int]] = None							):






							'''simple docstring'''


							if token_ids_a is None:
								return self.prefix_tokens + token_ids_a + self.suffix_tokens
							# We don't expect to process pairs, but leave the pair logic for API consistency
							return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens
						def SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	List[int]      ,       A_	:	Optional[List[int]] = None							):






							'''simple docstring'''


							__lowercase									=	[self.sep_token_id]
							__lowercase									=	[self.cls_token_id]

							if token_ids_a is None:
								return len(cls + token_ids_a + sep							) * [0]
							return len(cls + token_ids_a + sep + sep + token_ids_a + sep							) * [0]
						def SCREAMING_SNAKE_CASE_	(		self	:	Tuple      ,       A_	:	Any      ,       A_	:	str      ,       A_	:	Optional[str]      ,       A_	:	Optional[str]      ,       **A_	:	List[str]							):






							'''simple docstring'''


							if src_lang is None or tgt_lang is None:
								raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model"""							)
							__lowercase									=	src_lang
							__lowercase									=	self(A_      ,       add_special_tokens=A_      ,       return_tensors=A_      ,       **A_							)
							__lowercase									=	self.convert_tokens_to_ids(A_							)
							__lowercase									=	tgt_lang_id
							return inputs
						def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






							'''simple docstring'''


							__lowercase									=	{self.convert_ids_to_tokens(A_							): i for i in range(self.vocab_size							)}
							vocab.update(self.added_tokens_encoder							)
							return vocab
						def SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	str							):






							'''simple docstring'''


							return self.sp_model.encode(A_      ,       out_type=A_							)
						def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]      ,       A_	:	Optional[int]							):






							'''simple docstring'''


							if token in self.fairseq_tokens_to_ids:
								return self.fairseq_tokens_to_ids[token]
							__lowercase									=	self.sp_model.PieceToId(A_							)

							# Need to return unknown token if the SP model returned 0
							return spm_id + self.fairseq_offset if spm_id else self.unk_token_id
						def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]      ,       A_	:	Optional[int]							):






							'''simple docstring'''


							if index in self.fairseq_ids_to_tokens:
								return self.fairseq_ids_to_tokens[index]
							return self.sp_model.IdToPiece(index - self.fairseq_offset							)
						def SCREAMING_SNAKE_CASE_	(		self	:	Dict      ,       A_	:	Dict							):






							'''simple docstring'''


							__lowercase									=	"""""".join(A_							).replace(A_      ,       """ """							).strip()
							return out_string
						def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]      ,       A_	:	str      ,       A_	:	Optional[str] = None							):






							'''simple docstring'''


							if not os.path.isdir(A_							):
								logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''							)
								return
							__lowercase									=	os.path.join(
							    A_      ,       (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]							)

							if os.path.abspath(self.vocab_file							) != os.path.abspath(A_							) and os.path.isfile(self.vocab_file							):
								copyfile(self.vocab_file      ,       A_							)
							elif not os.path.isfile(self.vocab_file							):
								with open(A_      ,       """wb"""							) as fi:
									__lowercase									=	self.sp_model.serialized_model_proto()
									fi.write(A_							)

							return (out_vocab_file,)
						def SCREAMING_SNAKE_CASE_	(		self	:	Dict      ,       A_	:	List[str]      ,       A_	:	str = "eng_Latn"      ,       A_	:	Optional[List[str]] = None      ,       A_	:	str = "fra_Latn"      ,       **A_	:	Any      ,       ):






							'''simple docstring'''


							__lowercase									=	src_lang
							__lowercase									=	tgt_lang
							return super().prepare_seqaseq_batch(A_      ,       A_      ,       **A_							)
						def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






							'''simple docstring'''


							return self.set_src_lang_special_tokens(self.src_lang							)
						def SCREAMING_SNAKE_CASE_	(		self	:	List[str]							):






							'''simple docstring'''


							return self.set_tgt_lang_special_tokens(self.tgt_lang							)
						def SCREAMING_SNAKE_CASE_	(		self	:	Any      ,       A_	:	Any							):






							'''simple docstring'''


							__lowercase									=	self.lang_code_to_id[src_lang]
							if self.legacy_behaviour:
								__lowercase									=	[]
								__lowercase									=	[self.eos_token_id, self.cur_lang_code]
							else:
								__lowercase									=	[self.cur_lang_code]
								__lowercase									=	[self.eos_token_id]






						def SCREAMING_SNAKE_CASE_	(		self	:	Dict      ,       A_	:	str							):






							'''simple docstring'''


							__lowercase									=	self.lang_code_to_id[lang]
							if self.legacy_behaviour:
								__lowercase									=	[]
								__lowercase									=	[self.eos_token_id, self.cur_lang_code]
							else:
								__lowercase									=	[self.cur_lang_code]
								__lowercase									=	[self.eos_token_id]




"""simple docstring"""

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import ChineseCLIPImageProcessor





class    lowerCamelCase__						(		unittest.TestCase    ):
      def __init__(		self	:	List[Any]      ,       A_	:	List[str]      ,       A_	:	str=7      ,       A_	:	Optional[int]=3      ,       A_	:	str=1_8      ,       A_	:	Tuple=3_0      ,       A_	:	Optional[Any]=4_0_0      ,       A_	:	Union[str, Any]=True      ,       A_	:	str=None      ,       A_	:	str=True      ,       A_	:	Optional[Any]=None      ,       A_	:	List[Any]=True      ,       A_	:	Union[str, Any]=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]      ,       A_	:	str=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]      ,       A_	:	List[str]=True      ,       ):






       '''simple docstring'''


       __lowercase									=	size if size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
       __lowercase									=	crop_size if crop_size is not None else {"""height""": 1_8, """width""": 1_8}
       __lowercase									=	parent
       __lowercase									=	batch_size
       __lowercase									=	num_channels
       __lowercase									=	image_size
       __lowercase									=	min_resolution
       __lowercase									=	max_resolution
       __lowercase									=	do_resize
       __lowercase									=	size
       __lowercase									=	do_center_crop
       __lowercase									=	crop_size
       __lowercase									=	do_normalize
       __lowercase									=	image_mean
       __lowercase									=	image_std
       __lowercase									=	do_convert_rgb
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       return {
           "do_resize": self.do_resize,
           "size": self.size,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
           "do_normalize": self.do_normalize,
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_convert_rgb": self.do_convert_rgb,
       }






      def SCREAMING_SNAKE_CASE_	(		self	:	str      ,       A_	:	List[Any]=False      ,       A_	:	List[Any]=False      ,       A_	:	Optional[Any]=False							):






       '''simple docstring'''


       assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

       if equal_resolution:
        __lowercase									=	[]
        for i in range(self.batch_size							):
         image_inputs.append(
             np.random.randint(
                 2_5_5      ,       size=(self.num_channels, self.max_resolution, self.max_resolution)      ,       dtype=np.uinta							)							)
       else:
        __lowercase									=	[]
        for i in range(self.batch_size							):
         __lowercase							,		__lowercase									=	np.random.choice(np.arange(self.min_resolution      ,       self.max_resolution							)      ,       2							)
         image_inputs.append(np.random.randint(2_5_5      ,       size=(self.num_channels, width, height)      ,       dtype=np.uinta							)							)

       if not numpify and not torchify:
        # PIL expects the channel dimension as last dimension
        __lowercase									=	[Image.fromarray(np.moveaxis(A_      ,       0      ,       -1							)							) for x in image_inputs]

       if torchify:
        __lowercase									=	[torch.from_numpy(A_							) for x in image_inputs]

       return image_inputs






@require_torch
@require_vision
class    lowerCamelCase__						(		_a			,   unittest.TestCase    ):
      a :     Union[str, Any]											=		ChineseCLIPImageProcessor if is_vision_available() else None
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''simple docstring'''


       __lowercase									=	ChineseCLIPImageProcessingTester(self      ,       do_center_crop=A_							)
      @property
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       return self.image_processor_tester.prepare_image_processor_dict()
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class(**self.image_processor_dict							)
       self.assertTrue(hasattr(A_      ,       """do_resize"""							)							)
       self.assertTrue(hasattr(A_      ,       """size"""							)							)
       self.assertTrue(hasattr(A_      ,       """do_center_crop"""							)							)
       self.assertTrue(hasattr(A_      ,       """center_crop"""							)							)
       self.assertTrue(hasattr(A_      ,       """do_normalize"""							)							)
       self.assertTrue(hasattr(A_      ,       """image_mean"""							)							)
       self.assertTrue(hasattr(A_      ,       """image_std"""							)							)
       self.assertTrue(hasattr(A_      ,       """do_convert_rgb"""							)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class.from_dict(self.image_processor_dict							)
       self.assertEqual(image_processor.size      ,       {"""height""": 2_2_4, """width""": 2_2_4}							)
       self.assertEqual(image_processor.crop_size      ,       {"""height""": 1_8, """width""": 1_8}							)

       __lowercase									=	self.image_processing_class.from_dict(self.image_processor_dict      ,       size=4_2      ,       crop_size=8_4							)
       self.assertEqual(image_processor.size      ,       {"""shortest_edge""": 4_2}							)
       self.assertEqual(image_processor.crop_size      ,       {"""height""": 8_4, """width""": 8_4}							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       pass
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class(**self.image_processor_dict							)
       # create random PIL images
       __lowercase									=	self.image_processor_tester.prepare_inputs(equal_resolution=A_							)
       for image in image_inputs:
        self.assertIsInstance(A_      ,       Image.Image							)

       # Test not batched input
       __lowercase									=	image_processing(image_inputs[0]      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )

       # Test batched
       __lowercase									=	image_processing(A_      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )
      def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class(**self.image_processor_dict							)
       # create random numpy tensors
       __lowercase									=	self.image_processor_tester.prepare_inputs(equal_resolution=A_      ,       numpify=A_							)
       for image in image_inputs:
        self.assertIsInstance(A_      ,       np.ndarray							)

       # Test not batched input
       __lowercase									=	image_processing(image_inputs[0]      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )

       # Test batched
       __lowercase									=	image_processing(A_      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )






      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class(**self.image_processor_dict							)
       # create random PyTorch tensors
       __lowercase									=	self.image_processor_tester.prepare_inputs(equal_resolution=A_      ,       torchify=A_							)
       for image in image_inputs:
        self.assertIsInstance(A_      ,       torch.Tensor							)

       # Test not batched input
       __lowercase									=	image_processing(image_inputs[0]      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )

       # Test batched
       __lowercase									=	image_processing(A_      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )






@require_torch
@require_vision
class    lowerCamelCase__						(		_a			,   unittest.TestCase    ):
      a :     Optional[Any]											=		ChineseCLIPImageProcessor if is_vision_available() else None
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       __lowercase									=	ChineseCLIPImageProcessingTester(self      ,       num_channels=4      ,       do_center_crop=A_							)
       __lowercase									=	3
      @property
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       return self.image_processor_tester.prepare_image_processor_dict()
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class(**self.image_processor_dict							)
       self.assertTrue(hasattr(A_      ,       """do_resize"""							)							)
       self.assertTrue(hasattr(A_      ,       """size"""							)							)
       self.assertTrue(hasattr(A_      ,       """do_center_crop"""							)							)
       self.assertTrue(hasattr(A_      ,       """center_crop"""							)							)
       self.assertTrue(hasattr(A_      ,       """do_normalize"""							)							)
       self.assertTrue(hasattr(A_      ,       """image_mean"""							)							)
       self.assertTrue(hasattr(A_      ,       """image_std"""							)							)
       self.assertTrue(hasattr(A_      ,       """do_convert_rgb"""							)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       pass






      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       __lowercase									=	self.image_processing_class(**self.image_processor_dict							)
       # create random PIL images
       __lowercase									=	self.image_processor_tester.prepare_inputs(equal_resolution=A_							)
       for image in image_inputs:
        self.assertIsInstance(A_      ,       Image.Image							)

       # Test not batched input
       __lowercase									=	image_processing(image_inputs[0]      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               1,
               self.expected_encoded_image_num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )

       # Test batched
       __lowercase									=	image_processing(A_      ,       return_tensors="""pt"""							).pixel_values
       self.assertEqual(
           encoded_images.shape      ,       (
               self.image_processor_tester.batch_size,
               self.expected_encoded_image_num_channels,
               self.image_processor_tester.crop_size["""height"""],
               self.image_processor_tester.crop_size["""width"""],
           )      ,       )
