



import os
from typing import List, Optional, Union

from ...image_processing_utils import BatchFeature
from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
from ..auto import AutoTokenizer



class    UpperCAmelCase__(				lowerCamelCase						):

   '''simple docstring'''




   A     :	Any												=     ["image_processor", "tokenizer"]
   A     :	Tuple												=     "BlipImageProcessor"
   A     :	Any												=     "AutoTokenizer"


   def __init__(    self	:      Optional[int]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      int)						->					Dict:




         """simple docstring"""

         super().__init__(lowerCAmelCase      ,					lowerCAmelCase)

         # add QFormer tokenizer
         lowercase__  =	qformer_tokenizer


   def __call__(    self	:      str      ,					lowerCAmelCase	:      ImageInput = None      ,					lowerCAmelCase	:      Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None      ,					lowerCAmelCase	:      bool = True      ,					lowerCAmelCase	:      Union[bool, str, PaddingStrategy] = False      ,					lowerCAmelCase	:      Union[bool, str, TruncationStrategy] = None      ,					lowerCAmelCase	:      Optional[int] = None      ,					lowerCAmelCase	:      int = 0      ,					lowerCAmelCase	:      Optional[int] = None      ,					lowerCAmelCase	:      Optional[bool] = None      ,					lowerCAmelCase	:      bool = False      ,					lowerCAmelCase	:      bool = False      ,					lowerCAmelCase	:      bool = False      ,					lowerCAmelCase	:      bool = False      ,					lowerCAmelCase	:      bool = False      ,					lowerCAmelCase	:      bool = True      ,					lowerCAmelCase	:      Optional[Union[str, TensorType]] = None      ,					**lowerCAmelCase	:      Any      ,					)						->					BatchFeature:




         """simple docstring"""

         if images is None and text is None:
               raise ValueError('You have to specify at least images or text.')

         lowercase__  =	BatchFeature()

         if text is not None:
               lowercase__  =	self.tokenizer(
                   text=lowerCAmelCase      ,					add_special_tokens=lowerCAmelCase      ,					padding=lowerCAmelCase      ,					truncation=lowerCAmelCase      ,					max_length=lowerCAmelCase      ,					stride=lowerCAmelCase      ,					pad_to_multiple_of=lowerCAmelCase      ,					return_attention_mask=lowerCAmelCase      ,					return_overflowing_tokens=lowerCAmelCase      ,					return_special_tokens_mask=lowerCAmelCase      ,					return_offsets_mapping=lowerCAmelCase      ,					return_token_type_ids=lowerCAmelCase      ,					return_length=lowerCAmelCase      ,					verbose=lowerCAmelCase      ,					return_tensors=lowerCAmelCase      ,					**lowerCAmelCase      ,					)
               encoding.update(lowerCAmelCase)
               lowercase__  =	self.qformer_tokenizer(
                   text=lowerCAmelCase      ,					add_special_tokens=lowerCAmelCase      ,					padding=lowerCAmelCase      ,					truncation=lowerCAmelCase      ,					max_length=lowerCAmelCase      ,					stride=lowerCAmelCase      ,					pad_to_multiple_of=lowerCAmelCase      ,					return_attention_mask=lowerCAmelCase      ,					return_overflowing_tokens=lowerCAmelCase      ,					return_special_tokens_mask=lowerCAmelCase      ,					return_offsets_mapping=lowerCAmelCase      ,					return_token_type_ids=lowerCAmelCase      ,					return_length=lowerCAmelCase      ,					verbose=lowerCAmelCase      ,					return_tensors=lowerCAmelCase      ,					**lowerCAmelCase      ,					)
               lowercase__  =	qformer_text_encoding.pop('input_ids')
               lowercase__  =	qformer_text_encoding.pop('attention_mask')

         if images is not None:
               lowercase__  =	self.image_processor(lowerCAmelCase      ,					return_tensors=lowerCAmelCase)
               encoding.update(lowerCAmelCase)

         return encoding


   def       UpperCAmelCase		(    self	:      Dict      ,					*lowerCAmelCase	:      List[Any]      ,					**lowerCAmelCase	:      str)						->					List[str]:




         """simple docstring"""

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


   def       UpperCAmelCase		(    self	:      Any      ,					*lowerCAmelCase	:      int      ,					**lowerCAmelCase	:      List[Any])						->					Any:




         """simple docstring"""

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


   @property
   # Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names
   def       UpperCAmelCase		(    self	:      Optional[int])						->					Optional[int]:




         """simple docstring"""

         lowercase__  =	self.tokenizer.model_input_names
         lowercase__  =	self.image_processor.model_input_names
         return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))


   def       UpperCAmelCase		(    self	:      Tuple      ,					lowerCAmelCase	:      Any      ,					**lowerCAmelCase	:      Optional[int])						->					Any:




         """simple docstring"""

         if os.path.isfile(lowerCAmelCase):
               raise ValueError(f'''Provided path ({save_directory}) should be a directory, not a file''')
         os.makedirs(lowerCAmelCase      ,					exist_ok=lowerCAmelCase)
         lowercase__  =	os.path.join(lowerCAmelCase      ,					'qformer_tokenizer')
         self.qformer_tokenizer.save_pretrained(lowerCAmelCase)
         return super().save_pretrained(lowerCAmelCase      ,					**lowerCAmelCase)



   @classmethod
   def       UpperCAmelCase		(    cls	:      Tuple      ,					lowerCAmelCase	:      Any      ,					**lowerCAmelCase	:      List[Any])						->					List[Any]:




         """simple docstring"""

         lowercase__  =	AutoTokenizer.from_pretrained(lowerCAmelCase      ,					subfolder='qformer_tokenizer')
         lowercase__  =	cls._get_arguments_from_pretrained(lowerCAmelCase      ,					**lowerCAmelCase)
         args.append(lowerCAmelCase)
         return cls(*lowerCAmelCase)





import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class    UpperCAmelCase__(				lowerCamelCase  ,				lowerCamelCase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	str												=     IFImgaImgSuperResolutionPipeline
   A     :	Dict												=     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
   A     :	Any												=     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}						)
   A     :	str												=     PipelineTesterMixin.required_optional_params - {"latents"}


   def       UpperCAmelCase		(    self	:      Dict)						->					Dict:




         """simple docstring"""

         return self._get_superresolution_dummy_components()


   def       UpperCAmelCase		(    self	:      Optional[Any]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Union[str, Any]=0)						->					str:




         """simple docstring"""

         if str(lowerCAmelCase).startswith('mps'):
               lowercase__  =	torch.manual_seed(lowerCAmelCase)
         else:
               lowercase__  =	torch.Generator(device=lowerCAmelCase).manual_seed(lowerCAmelCase)

         lowercase__  =	floats_tensor((1, 3, 32, 32)      ,					rng=random.Random(lowerCAmelCase)).to(lowerCAmelCase)
         lowercase__  =	floats_tensor((1, 3, 16, 16)      ,					rng=random.Random(lowerCAmelCase)).to(lowerCAmelCase)

         lowercase__  =	{
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'original_image': original_image,
             'generator': generator,
             'num_inference_steps': 2,
             'output_type': 'numpy',
         }

         return inputs


   @unittest.skipIf(
       torch_device != 'cuda' or not is_xformers_available()      ,					reason='XFormers attention is only available with CUDA and `xformers` installed'      ,					)
   def       UpperCAmelCase		(    self	:      str)						->					Dict:




         """simple docstring"""

         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3)


   def       UpperCAmelCase		(    self	:      List[Any])						->					Dict:




         """simple docstring"""

         self._test_save_load_optional_components()


   @unittest.skipIf(torch_device != 'cuda'      ,					reason='float16 requires CUDA')
   def       UpperCAmelCase		(    self	:      Optional[Any])						->					List[Any]:




         """simple docstring"""

         super().test_save_load_floataa(expected_max_diff=1E-1)


   def       UpperCAmelCase		(    self	:      str)						->					Union[str, Any]:




         """simple docstring"""

         self._test_attention_slicing_forward_pass(expected_max_diff=1E-2)


   def       UpperCAmelCase		(    self	:      Tuple)						->					Tuple:




         """simple docstring"""

         self._test_save_load_local()



   def       UpperCAmelCase		(    self	:      List[str])						->					Tuple:




         """simple docstring"""

         self._test_inference_batch_single_identical(
             expected_max_diff=1E-2      ,					)
