




"""simple docstring"""

import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()



class 			_snake_case					(				UpperCamelCase__				,    unittest.TestCase							):

				'''simple docstring'''




				UpperCamelCase__		  =UnCLIPImageVariationPipeline
				UpperCamelCase__		  =IMAGE_VARIATION_PARAMS - {"""height""", """width""", """guidance_scale"""}
				UpperCamelCase__		  =IMAGE_VARIATION_BATCH_PARAMS

				UpperCamelCase__		  =[
				    """generator""",
				    """return_dict""",
				    """decoder_num_inference_steps""",
				    """super_res_num_inference_steps""",
				]
				UpperCamelCase__		  =False





				@property
				def 					snake_case_			(				self   :	List[str]  ):
								return 32





				@property
				def 					snake_case_			(				self   :	List[Any]  ):
								return 32





				@property
				def 					snake_case_			(				self   :	Optional[int]  ):
								return self.time_input_dim





				@property
				def 					snake_case_			(				self   :	List[str]  ):
								return self.time_input_dim * 4





				@property
				def 					snake_case_			(				self   :	Tuple  ):
								return 100





				@property
				def 					snake_case_			(				self   :	int  ):
								UpperCAmelCase_       :Dict         =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )
								return tokenizer





				@property
				def 					snake_case_			(				self   :	int  ):
								torch.manual_seed(0  )
								UpperCAmelCase_       :Tuple         =   CLIPTextConfig(
								    bos_token_id=0       ,				eos_token_id=2       ,				hidden_size=self.text_embedder_hidden_size       ,				projection_dim=self.text_embedder_hidden_size       ,				intermediate_size=37       ,				layer_norm_eps=1e-05       ,				num_attention_heads=4       ,				num_hidden_layers=5       ,				pad_token_id=1       ,				vocab_size=1_000       ,				)
								return CLIPTextModelWithProjection(__A  )





				@property
				def 					snake_case_			(				self   :	Union[str, Any]  ):
								torch.manual_seed(0  )
								UpperCAmelCase_       :Any         =   CLIPVisionConfig(
								    hidden_size=self.text_embedder_hidden_size       ,				projection_dim=self.text_embedder_hidden_size       ,				num_hidden_layers=5       ,				num_attention_heads=4       ,				image_size=32       ,				intermediate_size=37       ,				patch_size=1       ,				)
								return CLIPVisionModelWithProjection(__A  )





				@property
				def 					snake_case_			(				self   :	List[str]  ):
								torch.manual_seed(0  )

								UpperCAmelCase_       :List[str]         =   {
								    '''clip_embeddings_dim''': self.text_embedder_hidden_size,
								    '''time_embed_dim''': self.time_embed_dim,
								    '''cross_attention_dim''': self.cross_attention_dim,
								}

								UpperCAmelCase_       :Union[str, Any]         =   UnCLIPTextProjModel(**__A  )
								return model





				@property
				def 					snake_case_			(				self   :	Union[str, Any]  ):
								torch.manual_seed(0  )

								UpperCAmelCase_       :Union[str, Any]         =   {
								    '''sample_size''': 32,
								    # RGB in channels
								    '''in_channels''': 3,
								    # Out channels is double in channels because predicts mean and variance
								    '''out_channels''': 6,
								    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
								    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
								    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
								    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
								    '''layers_per_block''': 1,
								    '''cross_attention_dim''': self.cross_attention_dim,
								    '''attention_head_dim''': 4,
								    '''resnet_time_scale_shift''': '''scale_shift''',
								    '''class_embed_type''': '''identity''',
								}

								UpperCAmelCase_       :List[Any]         =   UNetaDConditionModel(**__A  )
								return model





				@property
				def 					snake_case_			(				self   :	List[str]  ):
								return {
								    "sample_size": 64,
								    "layers_per_block": 1,
								    "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
								    "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
								    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
								    "in_channels": 6,
								    "out_channels": 3,
								}





				@property
				def 					snake_case_			(				self   :	Tuple  ):
								torch.manual_seed(0  )

								UpperCAmelCase_       :Tuple         =   UNetaDModel(**self.dummy_super_res_kwargs  )
								return model





				@property
				def 					snake_case_			(				self   :	Optional[int]  ):
								torch.manual_seed(1  )

								UpperCAmelCase_       :Optional[Any]         =   UNetaDModel(**self.dummy_super_res_kwargs  )
								return model





				def 					snake_case_			(				self   :	str  ):
								UpperCAmelCase_       :Optional[Any]         =   self.dummy_decoder
								UpperCAmelCase_       :int         =   self.dummy_text_proj
								UpperCAmelCase_       :List[str]         =   self.dummy_text_encoder
								UpperCAmelCase_       :Tuple         =   self.dummy_tokenizer
								UpperCAmelCase_       :str         =   self.dummy_super_res_first
								UpperCAmelCase_       :Dict         =   self.dummy_super_res_last

								UpperCAmelCase_       :List[str]         =   UnCLIPScheduler(
								    variance_type='''learned_range'''       ,				prediction_type='''epsilon'''       ,				num_train_timesteps=1_000       ,				)

								UpperCAmelCase_       :Tuple         =   UnCLIPScheduler(
								    variance_type='''fixed_small_log'''       ,				prediction_type='''epsilon'''       ,				num_train_timesteps=1_000       ,				)

								UpperCAmelCase_       :List[Any]         =   CLIPImageProcessor(crop_size=32       ,				size=32  )

								UpperCAmelCase_       :Union[str, Any]         =   self.dummy_image_encoder

								return {
								    "decoder": decoder,
								    "text_encoder": text_encoder,
								    "tokenizer": tokenizer,
								    "text_proj": text_proj,
								    "feature_extractor": feature_extractor,
								    "image_encoder": image_encoder,
								    "super_res_first": super_res_first,
								    "super_res_last": super_res_last,
								    "decoder_scheduler": decoder_scheduler,
								    "super_res_scheduler": super_res_scheduler,
								}





				def 					snake_case_			(				self   :	Union[str, Any]       ,				snake_case   :	Optional[int]       ,				snake_case   :	List[str]=0       ,				snake_case   :	str=True  ):
								UpperCAmelCase_       :Any         =   floats_tensor((1, 3, 32, 32)       ,				rng=random.Random(__A  )  ).to(__A  )
								if str(__A  ).startswith('''mps'''  ):
												UpperCAmelCase_       :int         =   torch.manual_seed(__A  )
								else:
												UpperCAmelCase_       :Optional[int]         =   torch.Generator(device=__A  ).manual_seed(__A  )

								if pil_image:
												UpperCAmelCase_       :str         =   input_image * 0.5 + 0.5
												UpperCAmelCase_       :Optional[Any]         =   input_image.clamp(0       ,				1  )
												UpperCAmelCase_       :str         =   input_image.cpu().permute(0       ,				2       ,				3       ,				1  ).float().numpy()
												UpperCAmelCase_       :str         =   DiffusionPipeline.numpy_to_pil(__A  )[0]

								return {
								    "image": input_image,
								    "generator": generator,
								    "decoder_num_inference_steps": 2,
								    "super_res_num_inference_steps": 2,
								    "output_type": "np",
								}





				def 					snake_case_			(				self   :	str  ):
								UpperCAmelCase_       :List[Any]         =   '''cpu'''

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

								UpperCAmelCase_       :int         =   self.pipeline_class(**__A  )
								UpperCAmelCase_       :Dict         =   pipe.to(__A  )

								pipe.set_progress_bar_config(disable=__A  )

								UpperCAmelCase_       :List[Any]         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )

								UpperCAmelCase_       :Tuple         =   pipe(**__A  )
								UpperCAmelCase_       :Tuple         =   output.images

								UpperCAmelCase_       :Union[str, Any]         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )

								UpperCAmelCase_       :Dict         =   pipe(
								    **__A       ,				return_dict=__A       ,				)[0]

								UpperCAmelCase_       :int         =   image[0, -3:, -3:, -1]
								UpperCAmelCase_       :int         =   image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)

								UpperCAmelCase_       :int         =   np.array(
								    [
								        0.9_997,
								        0.0_002,
								        0.9_997,
								        0.9_997,
								        0.9_969,
								        0.0_023,
								        0.9_997,
								        0.9_969,
								        0.9_970,
								    ]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1e-2





				def 					snake_case_			(				self   :	List[Any]  ):
								UpperCAmelCase_       :Any         =   '''cpu'''

								UpperCAmelCase_       :int         =   self.get_dummy_components()

								UpperCAmelCase_       :List[Any]         =   self.pipeline_class(**__A  )
								UpperCAmelCase_       :Tuple         =   pipe.to(__A  )

								pipe.set_progress_bar_config(disable=__A  )

								UpperCAmelCase_       :Dict         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )

								UpperCAmelCase_       :Optional[int]         =   pipe(**__A  )
								UpperCAmelCase_       :List[str]         =   output.images

								UpperCAmelCase_       :int         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )

								UpperCAmelCase_       :Optional[Any]         =   pipe(
								    **__A       ,				return_dict=__A       ,				)[0]

								UpperCAmelCase_       :Union[str, Any]         =   image[0, -3:, -3:, -1]
								UpperCAmelCase_       :Tuple         =   image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)

								UpperCAmelCase_       :int         =   np.array([0.9_997, 0.0_003, 0.9_997, 0.9_997, 0.9_970, 0.0_024, 0.9_997, 0.9_971, 0.9_971]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1e-2





				def 					snake_case_			(				self   :	List[Any]  ):
								UpperCAmelCase_       :Optional[Any]         =   '''cpu'''

								UpperCAmelCase_       :Dict         =   self.get_dummy_components()

								UpperCAmelCase_       :Dict         =   self.pipeline_class(**__A  )
								UpperCAmelCase_       :List[Any]         =   pipe.to(__A  )

								pipe.set_progress_bar_config(disable=__A  )

								UpperCAmelCase_       :Optional[int]         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )
								UpperCAmelCase_       :Any         =   [
								    pipeline_inputs['''image'''],
								    pipeline_inputs['''image'''],
								]

								UpperCAmelCase_       :List[str]         =   pipe(**__A  )
								UpperCAmelCase_       :Any         =   output.images

								UpperCAmelCase_       :List[str]         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )
								UpperCAmelCase_       :List[Any]         =   [
								    tuple_pipeline_inputs['''image'''],
								    tuple_pipeline_inputs['''image'''],
								]

								UpperCAmelCase_       :List[Any]         =   pipe(
								    **__A       ,				return_dict=__A       ,				)[0]

								UpperCAmelCase_       :int         =   image[0, -3:, -3:, -1]
								UpperCAmelCase_       :Optional[int]         =   image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (2, 64, 64, 3)

								UpperCAmelCase_       :Optional[int]         =   np.array(
								    [
								        0.9_997,
								        0.9_989,
								        0.0_008,
								        0.0_021,
								        0.9_960,
								        0.0_018,
								        0.0_014,
								        0.0_002,
								        0.9_933,
								    ]  )

								assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1e-2





				def 					snake_case_			(				self   :	str  ):
								UpperCAmelCase_       :Optional[Any]         =   torch.device('''cpu'''  )



								class 			_snake_case					:

												'''simple docstring'''




												UpperCamelCase__		  =1


								UpperCAmelCase_       :Optional[int]         =   self.get_dummy_components()

								UpperCAmelCase_       :str         =   self.pipeline_class(**__A  )
								UpperCAmelCase_       :Tuple         =   pipe.to(__A  )

								pipe.set_progress_bar_config(disable=__A  )

								UpperCAmelCase_       :Any         =   torch.Generator(device=__A  ).manual_seed(0  )
								UpperCAmelCase_       :Tuple         =   pipe.decoder.dtype
								UpperCAmelCase_       :str         =   1

								UpperCAmelCase_       :int         =   (
								    batch_size,
								    pipe.decoder.config.in_channels,
								    pipe.decoder.config.sample_size,
								    pipe.decoder.config.sample_size,
								)
								UpperCAmelCase_       :Optional[Any]         =   pipe.prepare_latents(
								    __A       ,				dtype=__A       ,				device=__A       ,				generator=__A       ,				latents=__A       ,				scheduler=DummyScheduler()  )

								UpperCAmelCase_       :List[Any]         =   (
								    batch_size,
								    pipe.super_res_first.config.in_channels // 2,
								    pipe.super_res_first.config.sample_size,
								    pipe.super_res_first.config.sample_size,
								)
								UpperCAmelCase_       :List[Any]         =   pipe.prepare_latents(
								    __A       ,				dtype=__A       ,				device=__A       ,				generator=__A       ,				latents=__A       ,				scheduler=DummyScheduler()  )

								UpperCAmelCase_       :Optional[Any]         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )

								UpperCAmelCase_       :Dict         =   pipe(
								    **__A       ,				decoder_latents=__A       ,				super_res_latents=__A  ).images

								UpperCAmelCase_       :Union[str, Any]         =   self.get_dummy_inputs(__A       ,				pil_image=__A  )
								# Don't pass image, instead pass embedding
								UpperCAmelCase_       :Union[str, Any]         =   pipeline_inputs.pop('''image'''  )
								UpperCAmelCase_       :Optional[Any]         =   pipe.image_encoder(__A  ).image_embeds

								UpperCAmelCase_       :List[str]         =   pipe(
								    **__A       ,				decoder_latents=__A       ,				super_res_latents=__A       ,				image_embeddings=__A       ,				).images

								# make sure passing text embeddings manually is identical
								assert np.abs(img_out_a - img_out_a  ).max() < 1e-4





				@skip_mps
				def 					snake_case_			(				self   :	Any  ):
								UpperCAmelCase_       :Optional[Any]         =   torch_device == '''cpu'''

								# Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
								UpperCAmelCase_       :List[str]         =   1e-2

								self._test_attention_slicing_forward_pass(
								    test_max_difference=__A       ,				expected_max_diff=__A  )





				@skip_mps
				def 					snake_case_			(				self   :	Optional[int]  ):
								UpperCAmelCase_       :Union[str, Any]         =   torch_device == '''cpu'''
								UpperCAmelCase_       :Tuple         =   True
								UpperCAmelCase_       :Any         =   [
								    '''decoder_num_inference_steps''',
								    '''super_res_num_inference_steps''',
								]

								self._test_inference_batch_single_identical(
								    test_max_difference=__A       ,				relax_max_difference=__A       ,				additional_params_copy_to_batched_inputs=__A       ,				)





				def 					snake_case_			(				self   :	Tuple  ):
								UpperCAmelCase_       :Any         =   [
								    '''decoder_num_inference_steps''',
								    '''super_res_num_inference_steps''',
								]

								if torch_device == "mps":
												# TODO: MPS errors with larger batch sizes
												UpperCAmelCase_       :Optional[Any]         =   [2, 3]
												self._test_inference_batch_consistent(
												    batch_sizes=__A       ,				additional_params_copy_to_batched_inputs=__A       ,				)
								else:
												self._test_inference_batch_consistent(
												    additional_params_copy_to_batched_inputs=__A  )





				@skip_mps
				def 					snake_case_			(				self   :	Optional[int]  ):
								return super().test_dict_tuple_outputs_equivalent()





				@skip_mps
				def 					snake_case_			(				self   :	str  ):
								return super().test_save_load_local()





				@skip_mps
				def 					snake_case_			(				self   :	str  ):
								return super().test_save_load_optional_components()



@slow
@require_torch_gpu
class 			_snake_case					(				unittest.TestCase							):

				'''simple docstring'''




				def 					snake_case_			(				self   :	List[str]  ):
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()





				def 					snake_case_			(				self   :	int  ):
								UpperCAmelCase_       :Optional[int]         =   load_image(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''  )
								UpperCAmelCase_       :Optional[Any]         =   load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
								    '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''  )

								UpperCAmelCase_       :List[Any]         =   UnCLIPImageVariationPipeline.from_pretrained(
								    '''kakaobrain/karlo-v1-alpha-image-variations'''       ,				torch_dtype=torch.floataa  )
								UpperCAmelCase_       :Dict         =   pipeline.to(__A  )
								pipeline.set_progress_bar_config(disable=__A  )

								UpperCAmelCase_       :List[Any]         =   torch.Generator(device='''cpu'''  ).manual_seed(0  )
								UpperCAmelCase_       :Optional[Any]         =   pipeline(
								    __A       ,				generator=__A       ,				output_type='''np'''       ,				)

								UpperCAmelCase_       :Tuple         =   output.images[0]

								assert image.shape == (256, 256, 3)

								assert_mean_pixel_difference(__A       ,				__A       ,				15  )









import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available




class 	UpperCamelCase_							(  UpperCamelCase__     ):
							lowerCamelCase_							     =       ["image_processor", "tokenizer"]
							lowerCamelCase_							     =       "OwlViTImageProcessor"
							lowerCamelCase_							     =       ("CLIPTokenizer", "CLIPTokenizerFast")


							def __init__(				self     :Optional[Any]				,					__A     :int=None				,					__A     :Optional[int]=None				,					**__A     :str		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   None
									if "feature_extractor" in kwargs:
											warnings.warn(
											    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
											    """ instead."""				,					__A				,					)
											SCREAMING_SNAKE_CASE__								=   kwargs.pop("""feature_extractor"""		)

									SCREAMING_SNAKE_CASE__								=   image_processor if image_processor is not None else feature_extractor
									if image_processor is None:
											raise ValueError("""You need to specify an `image_processor`."""		)
									if tokenizer is None:
											raise ValueError("""You need to specify a `tokenizer`."""		)

									super().__init__(__A				,					__A		)


							def __call__(				self     :str				,					__A     :Dict=None				,					__A     :List[str]=None				,					__A     :str=None				,					__A     :Optional[int]="max_length"				,					__A     :Tuple="np"				,					**__A     :int		) -> Tuple:



									"""simple docstring"""



									if text is None and query_images is None and images is None:
											raise ValueError(
											    """You have to specify at least one text or query image or image. All three cannot be none."""		)

									if text is not None:
											if isinstance(__A				,					__A		) or (isinstance(__A				,					__A		) and not isinstance(text[0]				,					__A		)):
													SCREAMING_SNAKE_CASE__								=   [self.tokenizer(__A				,					padding=__A				,					return_tensors=__A				,					**__A		)]

											elif isinstance(__A				,					__A		) and isinstance(text[0]				,					__A		):
													SCREAMING_SNAKE_CASE__								=   []

													# Maximum number of queries across batch
													SCREAMING_SNAKE_CASE__								=   max([len(__A		) for t in text]		)

													# Pad all batch samples to max number of text queries
													for t in text:
															if len(__A		) != max_num_queries:
																	SCREAMING_SNAKE_CASE__								=   t + [""" """] * (max_num_queries - len(__A		))

															SCREAMING_SNAKE_CASE__								=   self.tokenizer(__A				,					padding=__A				,					return_tensors=__A				,					**__A		)
															encodings.append(__A		)
											else:
													raise TypeError("""Input text should be a string, a list of strings or a nested list of strings"""		)

											if return_tensors == "np":
													SCREAMING_SNAKE_CASE__								=   np.concatenate([encoding["""input_ids"""] for encoding in encodings]				,					axis=0		)
													SCREAMING_SNAKE_CASE__								=   np.concatenate([encoding["""attention_mask"""] for encoding in encodings]				,					axis=0		)

											elif return_tensors == "jax" and is_flax_available():
													import jax.numpy as jnp

													SCREAMING_SNAKE_CASE__								=   jnp.concatenate([encoding["""input_ids"""] for encoding in encodings]				,					axis=0		)
													SCREAMING_SNAKE_CASE__								=   jnp.concatenate([encoding["""attention_mask"""] for encoding in encodings]				,					axis=0		)

											elif return_tensors == "pt" and is_torch_available():
													import torch

													SCREAMING_SNAKE_CASE__								=   torch.cat([encoding["""input_ids"""] for encoding in encodings]				,					dim=0		)
													SCREAMING_SNAKE_CASE__								=   torch.cat([encoding["""attention_mask"""] for encoding in encodings]				,					dim=0		)

											elif return_tensors == "tf" and is_tf_available():
													import tensorflow as tf

													SCREAMING_SNAKE_CASE__								=   tf.stack([encoding["""input_ids"""] for encoding in encodings]				,					axis=0		)
													SCREAMING_SNAKE_CASE__								=   tf.stack([encoding["""attention_mask"""] for encoding in encodings]				,					axis=0		)

											else:
													raise ValueError("""Target return tensor type could not be returned"""		)

											SCREAMING_SNAKE_CASE__								=   BatchEncoding()
											SCREAMING_SNAKE_CASE__								=   input_ids
											SCREAMING_SNAKE_CASE__								=   attention_mask

									if query_images is not None:
											SCREAMING_SNAKE_CASE__								=   BatchEncoding()
											SCREAMING_SNAKE_CASE__								=   self.image_processor(
											    __A				,					return_tensors=__A				,					**__A		).pixel_values
											SCREAMING_SNAKE_CASE__								=   query_pixel_values

									if images is not None:
											SCREAMING_SNAKE_CASE__								=   self.image_processor(__A				,					return_tensors=__A				,					**__A		)

									if text is not None and images is not None:
											SCREAMING_SNAKE_CASE__								=   image_features.pixel_values
											return encoding
									elif query_images is not None and images is not None:
											SCREAMING_SNAKE_CASE__								=   image_features.pixel_values
											return encoding
									elif text is not None or query_images is not None:
											return encoding
									else:
											return BatchEncoding(data=dict(**__A		)				,					tensor_type=__A		)


							def   _snake_case	(				self     :List[Any]				,					*__A     :Dict				,					**__A     :Dict		) -> Optional[int]:



									"""simple docstring"""



									return self.image_processor.post_process(*__A				,					**__A		)


							def   _snake_case	(				self     :Optional[int]				,					*__A     :Dict				,					**__A     :List[str]		) -> Optional[Any]:



									"""simple docstring"""



									return self.image_processor.post_process_object_detection(*__A				,					**__A		)


							def   _snake_case	(				self     :str				,					*__A     :List[str]				,					**__A     :Union[str, Any]		) -> Any:



									"""simple docstring"""



									return self.image_processor.post_process_image_guided_detection(*__A				,					**__A		)


							def   _snake_case	(				self     :Dict				,					*__A     :List[str]				,					**__A     :List[str]		) -> int:



									"""simple docstring"""



									return self.tokenizer.batch_decode(*__A				,					**__A		)


							def   _snake_case	(				self     :Dict				,					*__A     :Dict				,					**__A     :List[str]		) -> str:



									"""simple docstring"""



									return self.tokenizer.decode(*__A				,					**__A		)


							@property
							def   _snake_case	(				self     :List[Any]		) -> Optional[int]:



									"""simple docstring"""



									warnings.warn(
									    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""				,					__A				,					)
									return self.image_processor_class


							@property
							def   _snake_case	(				self     :Any		) -> Optional[Any]:



									"""simple docstring"""



									warnings.warn(
									    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""				,					__A				,					)
									return self.image_processor