






"""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, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import PoolFormerImageProcessor

class        a     (   unittest.TestCase	):







    def __init__(			self							,		_lowerCamelCase							,		_lowerCamelCase=7							,		_lowerCamelCase=3							,		_lowerCamelCase=3_0							,		_lowerCamelCase=4_0_0							,		_lowerCamelCase=True							,		_lowerCamelCase=None							,		_lowerCamelCase=0.9							,		_lowerCamelCase=None							,		_lowerCamelCase=True							,		_lowerCamelCase=[0.5, 0.5, 0.5]							,		_lowerCamelCase=[0.5, 0.5, 0.5]							,		):
      lowercase							    =       size if size is not None else {'shortest_edge': 3_0}
      lowercase							    =       crop_size if crop_size is not None else {'height': 3_0, 'width': 3_0}
      lowercase							    =       parent
      lowercase							    =       batch_size
      lowercase							    =       num_channels
      lowercase							    =       min_resolution
      lowercase							    =       max_resolution
      lowercase							    =       do_resize_and_center_crop
      lowercase							    =       size
      lowercase							    =       crop_pct
      lowercase							    =       crop_size
      lowercase							    =       do_normalize
      lowercase							    =       image_mean
      lowercase							    =       image_std







    def 			UpperCamelCase_      (			self       ):
      return {
          "size": self.size,
          "do_resize_and_center_crop": self.do_resize_and_center_crop,
          "crop_pct": self.crop_pct,
          "crop_size": self.crop_size,
          "do_normalize": self.do_normalize,
          "image_mean": self.image_mean,
          "image_std": self.image_std,
      }


@require_torch
@require_vision
class        a     (   a_,				unittest.TestCase	):
    UpperCAmelCase_ :     List[str]	     =PoolFormerImageProcessor if is_vision_available() else None







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       PoolFormerImageProcessingTester(self       )







    @property
    def 			UpperCamelCase_      (			self       ):
      return self.image_processor_tester.prepare_image_processor_dict()







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.image_processing_class(**self.image_processor_dict       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'do_resize_and_center_crop'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'size'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'crop_pct'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'do_normalize'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'image_mean'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'image_std'       )       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.image_processing_class.from_dict(self.image_processor_dict       )
      self.assertEqual(image_processor.size							,		{'shortest_edge': 3_0}       )
      self.assertEqual(image_processor.crop_size							,		{'height': 3_0, 'width': 3_0}       )

      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 			UpperCamelCase_      (			self       ):
      pass







    def 			UpperCamelCase_      (			self       ):
      # Initialize image_processing
      lowercase							    =       self.image_processing_class(**self.image_processor_dict       )
      # create random PIL images
      lowercase							    =       prepare_image_inputs(self.image_processor_tester							,		equal_resolution=_lowerCamelCase       )
      for image in image_inputs:
        self.assertIsInstance(_lowerCamelCase							,		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(_lowerCamelCase							,		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 			UpperCamelCase_      (			self       ):
      # Initialize image_processing
      lowercase							    =       self.image_processing_class(**self.image_processor_dict       )
      # create random numpy tensors
      lowercase							    =       prepare_image_inputs(self.image_processor_tester							,		equal_resolution=_lowerCamelCase							,		numpify=_lowerCamelCase       )
      for image in image_inputs:
        self.assertIsInstance(_lowerCamelCase							,		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(_lowerCamelCase							,		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 			UpperCamelCase_      (			self       ):
      # Initialize image_processing
      lowercase							    =       self.image_processing_class(**self.image_processor_dict       )
      # create random PyTorch tensors
      lowercase							    =       prepare_image_inputs(self.image_processor_tester							,		equal_resolution=_lowerCamelCase							,		torchify=_lowerCamelCase       )
      for image in image_inputs:
        self.assertIsInstance(_lowerCamelCase							,		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(_lowerCamelCase							,		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'],
          )							,		)










"""simple docstring"""



def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  List[str]		,					__snake_case			:  List[str]    ):





  '''simple docstring'''





  lowercase							    =       ''
  for i in table:
    res += inp[i - 1]
  return res
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  str    ):





  '''simple docstring'''





  return data[1:] + data[0]
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  List[str]		,					__snake_case			:  Optional[int]    ):





  '''simple docstring'''





  lowercase							    =       ''
  for i in range(len(__snake_case    )    ):
    if a[i] == b[i]:
      res += "0"
    else:
      res += "1"
  return res
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Dict		,					__snake_case			:  Optional[Any]    ):





  '''simple docstring'''





  lowercase							    =       int('0b' + data[0] + data[-1]		,					2    )
  lowercase							    =       int('0b' + data[1:3]		,					2    )
  return bin(s[row][col]    )[2:]
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Union[str, Any]		,					__snake_case			:  Union[str, Any]		,					__snake_case			:  Dict		,					__snake_case			:  Union[str, Any]		,					__snake_case			:  Optional[int]    ):





  '''simple docstring'''





  lowercase							    =       message[:4]
  lowercase							    =       message[4:]
  lowercase							    =       apply_table(__snake_case		,					__snake_case    )
  lowercase							    =       xor(__snake_case		,					__snake_case    )
  lowercase							    =       apply_sbox(__snake_case		,					temp[:4]    )  # noqa: E741
  lowercase							    =       apply_sbox(__snake_case		,					temp[4:]    )
  lowercase							    =       '0' * (2 - len(__snake_case    )) + l  # noqa: E741
  lowercase							    =       '0' * (2 - len(__snake_case    )) + r
  lowercase							    =       apply_table(l + r		,					__snake_case    )
  lowercase							    =       xor(__snake_case		,					__snake_case    )
  return temp + right


if __name__ == "__main__":
    _UpperCamelCase		:  Dict						=		input('Enter 10 bit key: ')
    _UpperCamelCase		:  int						=		input('Enter 8 bit message: ')

    _UpperCamelCase		:  Optional[int]						=		[6, 3, 7, 4, 8, 5, 1_0, 9]
    _UpperCamelCase		:  Optional[Any]						=		[3, 5, 2, 7, 4, 1_0, 1, 9, 8, 6]
    _UpperCamelCase		:  str						=		[2, 4, 3, 1]
    _UpperCamelCase		:  List[Any]						=		[2, 6, 3, 1, 4, 8, 5, 7]
    _UpperCamelCase		:  List[str]						=		[4, 1, 3, 5, 7, 2, 8, 6]
    _UpperCamelCase		:  int						=		[4, 1, 2, 3, 2, 3, 4, 1]
    _UpperCamelCase		:  Optional[Any]						=		[[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
    _UpperCamelCase		:  Optional[int]						=		[[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

    # key generation
    _UpperCamelCase		:  str						=		apply_table(key, paa_table)
    _UpperCamelCase		:  Union[str, Any]						=		temp[:5]
    _UpperCamelCase		:  Dict						=		temp[5:]
    _UpperCamelCase		:  List[Any]						=		left_shift(left)
    _UpperCamelCase		:  str						=		left_shift(right)
    _UpperCamelCase		:  int						=		apply_table(left + right, pa_table)
    _UpperCamelCase		:  Optional[int]						=		left_shift(left)
    _UpperCamelCase		:  Any						=		left_shift(right)
    _UpperCamelCase		:  str						=		left_shift(left)
    _UpperCamelCase		:  Tuple						=		left_shift(right)
    _UpperCamelCase		:  Union[str, Any]						=		apply_table(left + right, pa_table)

    # encryption
    _UpperCamelCase		:  Tuple						=		apply_table(message, IP)
    _UpperCamelCase		:  Any						=		function(expansion, sa, sa, keya, temp)
    _UpperCamelCase		:  List[Any]						=		temp[4:] + temp[:4]
    _UpperCamelCase		:  List[str]						=		function(expansion, sa, sa, keya, temp)
    _UpperCamelCase		:  int						=		apply_table(temp, IP_inv)
    print('Cipher text is:', CT)

    # decryption
    _UpperCamelCase		:  List[Any]						=		apply_table(CT, IP)
    _UpperCamelCase		:  Optional[Any]						=		function(expansion, sa, sa, keya, temp)
    _UpperCamelCase		:  int						=		temp[4:] + temp[:4]
    _UpperCamelCase		:  str						=		function(expansion, sa, sa, keya, temp)
    _UpperCamelCase		:  List[Any]						=		apply_table(temp, IP_inv)
    print('Plain text after decypting is:', PT)


