




'''simple docstring'''



import shutil
import tempfile
import unittest

import numpy as np
import pytest

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


if is_torch_available():
 from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
 lowerCamelCase_	 =		False

if is_vision_available():
 from PIL import Image

 from transformers import (
     AutoProcessor,
     PixaStructImageProcessor,
     PixaStructProcessor,
     PreTrainedTokenizerFast,
     TaTokenizer,
 )







@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11  ,						reason='''`Pix2StructImageProcessor` requires `torch>=1.11.0`.'''  ,						)
@require_vision
@require_torch
class 	lowercase_					(				unittest.TestCase     ):


   """simple docstring"""

   def 							lowerCAmelCase_    (					self      :			List[Any]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   tempfile.mkdtemp()

      _SCREAMING_SNAKE_CASE =   PixaStructImageProcessor()
      _SCREAMING_SNAKE_CASE =   TaTokenizer.from_pretrained("t5-small"					)

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(__lowerCamelCase						,   __lowerCamelCase					)

      processor.save_pretrained(self.tmpdirname					)



   def 							lowerCAmelCase_    (					self      :			Union[str, Any]						,   **__lowerCamelCase      :			Union[str, Any]					):

      """simple docstring"""
      return AutoProcessor.from_pretrained(self.tmpdirname						,   **__lowerCamelCase					).tokenizer



   def 							lowerCAmelCase_    (					self      :			int						,   **__lowerCamelCase      :			Optional[Any]					):

      """simple docstring"""
      return AutoProcessor.from_pretrained(self.tmpdirname						,   **__lowerCamelCase					).image_processor



   def 							lowerCAmelCase_    (					self      :			Tuple					):

      """simple docstring"""
      shutil.rmtree(self.tmpdirname					)



   def 							lowerCAmelCase_    (					self      :			int					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   [np.random.randint(2_5_5						,   size=(3, 3_0, 4_0_0)						,   dtype=np.uinta					)]

      _SCREAMING_SNAKE_CASE =   [Image.fromarray(np.moveaxis(__lowerCamelCase						,   0						,   -1					)					) for x in image_inputs]

      return image_inputs



   def 							lowerCAmelCase_    (					self      :			int					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=self.get_tokenizer()						,   image_processor=self.get_image_processor()					)
      processor.save_pretrained(self.tmpdirname					)

      _SCREAMING_SNAKE_CASE =   self.get_tokenizer(bos_token="(BOS)"						,   eos_token="(EOS)"					)
      _SCREAMING_SNAKE_CASE =   self.get_image_processor(do_normalize=__lowerCamelCase						,   padding_value=1.0					)

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor.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					)



   def 							lowerCAmelCase_    (					self      :			str					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.get_image_processor()
      _SCREAMING_SNAKE_CASE =   self.get_tokenizer()

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=__lowerCamelCase						,   image_processor=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   self.prepare_image_inputs()

      _SCREAMING_SNAKE_CASE =   image_processor(__lowerCamelCase						,   return_tensors="np"					)
      _SCREAMING_SNAKE_CASE =   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 							lowerCAmelCase_    (					self      :			Any					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.get_image_processor()
      _SCREAMING_SNAKE_CASE =   self.get_tokenizer()

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=__lowerCamelCase						,   image_processor=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   "lower newer"

      _SCREAMING_SNAKE_CASE =   processor(text=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   tokenizer(__lowerCamelCase						,   return_token_type_ids=__lowerCamelCase						,   add_special_tokens=__lowerCamelCase					)

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



   def 							lowerCAmelCase_    (					self      :			Optional[int]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.get_image_processor()
      _SCREAMING_SNAKE_CASE =   self.get_tokenizer()

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=__lowerCamelCase						,   image_processor=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   "lower newer"
      _SCREAMING_SNAKE_CASE =   self.prepare_image_inputs()

      _SCREAMING_SNAKE_CASE =   processor(text=__lowerCamelCase						,   images=__lowerCamelCase					)

      self.assertListEqual(
          list(inputs.keys()					)						,   ["flattened_patches", "attention_mask", "decoder_attention_mask", "decoder_input_ids"]					)

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



   def 							lowerCAmelCase_    (					self      :			Union[str, Any]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.get_image_processor()
      _SCREAMING_SNAKE_CASE =   self.get_tokenizer()

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=__lowerCamelCase						,   image_processor=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   "lower newer"
      _SCREAMING_SNAKE_CASE =   self.prepare_image_inputs()

      _SCREAMING_SNAKE_CASE =   processor(text=__lowerCamelCase						,   images=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   [5_1_2, 1_0_2_4, 2_0_4_8, 4_0_9_6]
      _SCREAMING_SNAKE_CASE =   [7_7_0, 7_7_0, 7_7_0, 7_7_0]
      # with text
      for i, max_patch in enumerate(__lowerCamelCase					):
         _SCREAMING_SNAKE_CASE =   processor(text=__lowerCamelCase						,   images=__lowerCamelCase						,   max_patches=__lowerCamelCase					)
         self.assertEqual(inputs["flattened_patches"][0].shape[0]						,   __lowerCamelCase					)
         self.assertEqual(inputs["flattened_patches"][0].shape[1]						,   expected_hidden_size[i]					)

      # without text input
      for i, max_patch in enumerate(__lowerCamelCase					):
         _SCREAMING_SNAKE_CASE =   processor(images=__lowerCamelCase						,   max_patches=__lowerCamelCase					)
         self.assertEqual(inputs["flattened_patches"][0].shape[0]						,   __lowerCamelCase					)
         self.assertEqual(inputs["flattened_patches"][0].shape[1]						,   expected_hidden_size[i]					)



   def 							lowerCAmelCase_    (					self      :			Optional[int]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.get_image_processor()
      _SCREAMING_SNAKE_CASE =   self.get_tokenizer()

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=__lowerCamelCase						,   image_processor=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      _SCREAMING_SNAKE_CASE =   processor.batch_decode(__lowerCamelCase					)
      _SCREAMING_SNAKE_CASE =   tokenizer.batch_decode(__lowerCamelCase					)

      self.assertListEqual(__lowerCamelCase						,   __lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Optional[int]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.get_image_processor()
      _SCREAMING_SNAKE_CASE =   self.get_tokenizer()

      _SCREAMING_SNAKE_CASE =   PixaStructProcessor(tokenizer=__lowerCamelCase						,   image_processor=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   "lower newer"
      _SCREAMING_SNAKE_CASE =   self.prepare_image_inputs()

      _SCREAMING_SNAKE_CASE =   processor(text=__lowerCamelCase						,   images=__lowerCamelCase					)

      # For now the processor supports only ["flattened_patches", "input_ids", "attention_mask", "decoder_attention_mask"]
      self.assertListEqual(
          list(inputs.keys()					)						,   ["flattened_patches", "attention_mask", "decoder_attention_mask", "decoder_input_ids"]					)

      _SCREAMING_SNAKE_CASE =   processor(text=__lowerCamelCase					)

      # For now the processor supports only ["flattened_patches", "input_ids", "attention_mask", "decoder_attention_mask"]
      self.assertListEqual(list(inputs.keys()					)						,   ["input_ids", "attention_mask"]					)







'''simple docstring'''



def 				SCREAMING_SNAKE_CASE_				(							__A       :				List[Any] ,  __A       :				Dict						)				->				Union[str, Any]:
   if n == 0:
      return 1

   elif n % 2 == 1:
      return binary_exponentiation(__A ,  n - 1						) * a

   else:
      _SCREAMING_SNAKE_CASE =   binary_exponentiation(__A ,  n / 2						)
      return b * b


if __name__ == "__main__":
 try:
  lowerCamelCase_	 =		int(input('Enter Base : ').strip())
  lowerCamelCase_	 =		int(input('Enter Power : ').strip())
 except ValueError:
  print('Invalid literal for integer')

 lowerCamelCase_	 =		binary_exponentiation(BASE, POWER)
 print(f'''{BASE}^({POWER}) : {RESULT}''')

