


import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
				from PIL import Image

				from transformers import (
				    AutoProcessor,
				    BertTokenizerFast,
				    BlipImageProcessor,
				    GPTaTokenizer,
				    InstructBlipProcessor,
				    PreTrainedTokenizerFast,
				)







@require_vision
class 	__lowercase    (unittest.TestCase  ):





							"""simple docstring"""







							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					tempfile.mkdtemp()

										SCREAMING_SNAKE_CASE_		:     Dict					=					BlipImageProcessor()
										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					GPTaTokenizer.from_pretrained('hf-internal-testing/tiny-random-GPT2Model'       )
										SCREAMING_SNAKE_CASE_		:     str					=					BertTokenizerFast.from_pretrained('hf-internal-testing/tiny-random-bert'       )

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					InstructBlipProcessor(lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__       )

										processor.save_pretrained(self.tmpdirname       )






							def 					UpperCamelCase__     (      self			,						**lowerCAmelCase__       ):





										"""simple docstring"""




										return AutoProcessor.from_pretrained(self.tmpdirname			,						**lowerCAmelCase__       ).tokenizer






							def 					UpperCamelCase__     (      self			,						**lowerCAmelCase__       ):





										"""simple docstring"""




										return AutoProcessor.from_pretrained(self.tmpdirname			,						**lowerCAmelCase__       ).image_processor






							def 					UpperCamelCase__     (      self			,						**lowerCAmelCase__       ):





										"""simple docstring"""




										return AutoProcessor.from_pretrained(self.tmpdirname			,						**lowerCAmelCase__       ).qformer_tokenizer






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										shutil.rmtree(self.tmpdirname       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					[np.random.randint(2_5_5			,						size=(3, 3_0, 4_0_0)			,						dtype=np.uinta       )]

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					[Image.fromarray(np.moveaxis(lowerCAmelCase__			,						0			,						-1       )       ) for x in image_inputs]

										return image_inputs






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     str					=					InstructBlipProcessor(
										    tokenizer=self.get_tokenizer()			,						image_processor=self.get_image_processor()			,						qformer_tokenizer=self.get_qformer_tokenizer()			,						)
										processor.save_pretrained(self.tmpdirname       )

										SCREAMING_SNAKE_CASE_		:     str					=					self.get_tokenizer(bos_token='(BOS)'			,						eos_token='(EOS)'       )
										SCREAMING_SNAKE_CASE_		:     int					=					self.get_image_processor(do_normalize=lowerCAmelCase__			,						padding_value=1.0       )

										SCREAMING_SNAKE_CASE_		:     Any					=					InstructBlipProcessor.from_pretrained(
										    self.tmpdirname			,						bos_token='(BOS)'			,						eos_token='(EOS)'			,						do_normalize=lowerCAmelCase__			,						padding_value=1.0       )

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

										self.assertEqual(processor.image_processor.to_json_string()			,						image_processor_add_kwargs.to_json_string()       )
										self.assertIsInstance(processor.image_processor			,						lowerCAmelCase__       )
										self.assertIsInstance(processor.qformer_tokenizer			,						lowerCAmelCase__       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[Any]					=					self.get_image_processor()
										SCREAMING_SNAKE_CASE_		:     List[str]					=					self.get_tokenizer()
										SCREAMING_SNAKE_CASE_		:     Dict					=					self.get_qformer_tokenizer()

										SCREAMING_SNAKE_CASE_		:     str					=					InstructBlipProcessor(
										    tokenizer=lowerCAmelCase__			,						image_processor=lowerCAmelCase__			,						qformer_tokenizer=lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     List[Any]					=					self.prepare_image_inputs()

										SCREAMING_SNAKE_CASE_		:     List[str]					=					image_processor(lowerCAmelCase__			,						return_tensors='np'       )
										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					processor(images=lowerCAmelCase__			,						return_tensors='np'       )

										for key in input_feat_extract.keys():
													self.assertAlmostEqual(input_feat_extract[key].sum()			,						input_processor[key].sum()			,						delta=1E-2       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					self.get_image_processor()
										SCREAMING_SNAKE_CASE_		:     Tuple					=					self.get_tokenizer()
										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					self.get_qformer_tokenizer()

										SCREAMING_SNAKE_CASE_		:     Any					=					InstructBlipProcessor(
										    tokenizer=lowerCAmelCase__			,						image_processor=lowerCAmelCase__			,						qformer_tokenizer=lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     Tuple					=					'lower newer'

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					processor(text=lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     Dict					=					tokenizer(lowerCAmelCase__			,						return_token_type_ids=lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Tuple					=					qformer_tokenizer(lowerCAmelCase__			,						return_token_type_ids=lowerCAmelCase__       )

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

										for key in encoded_tokens_qformer.keys():
													self.assertListEqual(encoded_tokens_qformer[key]			,						encoded_processor['qformer_' + key]       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					self.get_image_processor()
										SCREAMING_SNAKE_CASE_		:     str					=					self.get_tokenizer()
										SCREAMING_SNAKE_CASE_		:     List[Any]					=					self.get_qformer_tokenizer()

										SCREAMING_SNAKE_CASE_		:     Tuple					=					InstructBlipProcessor(
										    tokenizer=lowerCAmelCase__			,						image_processor=lowerCAmelCase__			,						qformer_tokenizer=lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     Tuple					=					'lower newer'
										SCREAMING_SNAKE_CASE_		:     int					=					self.prepare_image_inputs()

										SCREAMING_SNAKE_CASE_		:     List[str]					=					processor(text=lowerCAmelCase__			,						images=lowerCAmelCase__       )

										self.assertListEqual(
										    list(inputs.keys()       )			,						['input_ids', 'attention_mask', 'qformer_input_ids', 'qformer_attention_mask', 'pixel_values']			,						)

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






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					self.get_image_processor()
										SCREAMING_SNAKE_CASE_		:     str					=					self.get_tokenizer()
										SCREAMING_SNAKE_CASE_		:     List[str]					=					self.get_qformer_tokenizer()

										SCREAMING_SNAKE_CASE_		:     List[str]					=					InstructBlipProcessor(
										    tokenizer=lowerCAmelCase__			,						image_processor=lowerCAmelCase__			,						qformer_tokenizer=lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     List[str]					=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					processor.batch_decode(lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Any					=					tokenizer.batch_decode(lowerCAmelCase__       )

										self.assertListEqual(lowerCAmelCase__			,						lowerCAmelCase__       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Dict					=					self.get_image_processor()
										SCREAMING_SNAKE_CASE_		:     str					=					self.get_tokenizer()
										SCREAMING_SNAKE_CASE_		:     List[Any]					=					self.get_qformer_tokenizer()

										SCREAMING_SNAKE_CASE_		:     Tuple					=					InstructBlipProcessor(
										    tokenizer=lowerCAmelCase__			,						image_processor=lowerCAmelCase__			,						qformer_tokenizer=lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     List[Any]					=					'lower newer'
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					self.prepare_image_inputs()

										SCREAMING_SNAKE_CASE_		:     Any					=					processor(text=lowerCAmelCase__			,						images=lowerCAmelCase__       )

										self.assertListEqual(
										    list(inputs.keys()       )			,						['input_ids', 'attention_mask', 'qformer_input_ids', 'qformer_attention_mask', 'pixel_values']			,						)







"""simple docstring"""




import builtins
import sys

from ...utils.imports import _is_package_available
from . import cursor, input
from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
from .keymap import KEYMAP


_A     :			str  						=			False
try:
   _A     :			Dict  						=			_is_package_available("""google.colab""")
except ModuleNotFoundError:
   pass

@input.register
class 						a__		:
   def __init__(     self      ,       _a = None      ,       _a = []							):
          lowercase       :							Union[str, Any]									=				0
          lowercase       :							str									=				choices
          lowercase       :							List[Any]									=				prompt
          if sys.platform == "win32":
                 lowercase       :							Union[str, Any]									=				"*"
          else:
                 lowercase       :							int									=				"➔ "
   def      __magic_name__     (     self      ,       _a      ,       _a = ""							):
          if sys.platform != "win32":
                 writeColor(self.choices[index]      ,       32      ,       _a							)
          else:
                 forceWrite(self.choices[index]      ,       _a							)
   def      __magic_name__     (     self      ,       _a							):
          if index == self.position:
                 forceWrite(f""" {self.arrow_char} """							)
                 self.write_choice(_a							)
          else:
                 forceWrite(f"""    {self.choices[index]}"""							)
          reset_cursor()
   def      __magic_name__     (     self      ,       _a      ,       _a = 1							):
          lowercase       :							Optional[int]									=				self.position
          if direction == Direction.DOWN:
                 if self.position + 1 >= len(self.choices							):
                        return
                 self.position += num_spaces
          else:
                 if self.position - 1 < 0:
                        return
                 self.position -= num_spaces
          clear_line()
          self.print_choice(_a							)
          move_cursor(_a      ,       direction.name							)
          self.print_choice(self.position							)
   @input.mark(KEYMAP["up"]							)
   def      __magic_name__     (     self							):
          self.move_direction(Direction.UP							)
   @input.mark(KEYMAP["down"]							)
   def      __magic_name__     (     self							):
          self.move_direction(Direction.DOWN							)
   @input.mark(KEYMAP["newline"]							)
   def      __magic_name__     (     self							):
          move_cursor(len(self.choices							) - self.position      ,       "DOWN"							)
          return self.position
   @input.mark(KEYMAP["interrupt"]							)
   def      __magic_name__     (     self							):
          move_cursor(len(self.choices							) - self.position      ,       "DOWN"							)
          raise KeyboardInterrupt
   @input.mark_multiple(*[KEYMAP[str(_a							)] for number in range(10							)]							)
   def      __magic_name__     (     self							):
          lowercase       :							List[str]									=				int(chr(self.current_selection							)							)
          lowercase       :							Union[str, Any]									=				index - self.position
          if index == self.position:
                 return
          if index < len(self.choices							):
                 if self.position > index:
                        self.move_direction(Direction.UP      ,       -movement							)
                 elif self.position < index:
                        self.move_direction(Direction.DOWN      ,       _a							)
                 else:
                        return
          else:
                 return

   def      __magic_name__     (     self      ,       _a = 0							):
          if self.prompt:
                 linebreak()
                 forceWrite(self.prompt      ,       "\n"							)
                 if in_colab:
                        forceWrite("Please input a choice index (starting from 0), and press enter"      ,       "\n"							)
                 else:
                        forceWrite("Please select a choice using the arrow or number keys, and selecting with enter"      ,       "\n"							)
          lowercase       :							Tuple									=				default_choice
          for i in range(len(self.choices							)							):
                 self.print_choice(_a							)
                 forceWrite("\n"							)
          move_cursor(len(self.choices							) - self.position      ,       "UP"							)
          with cursor.hide():
                 while True:
                        if in_colab:
                               try:
                                      lowercase       :							Tuple									=				int(builtins.input()							)
                               except ValueError:
                                      lowercase       :							Optional[int]									=				default_choice
                        else:
                               lowercase       :							int									=				self.handle_input()
                        if choice is not None:
                               reset_cursor()
                               for _ in range(len(self.choices							) + 1							):
                                      move_cursor(1      ,       "UP"							)
                                      clear_line()
                               self.write_choice(_a      ,       "\n"							)
                               return choice


