



'''simple docstring'''





import unittest
from typing import Dict, List, Optional, Union

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 BridgeTowerImageProcessor






class __A    (						unittest.TestCase		):



	'''simple docstring'''







	def __init__(self				,     A				,     A = True				,     A = None				,     A = 32				,     A = True				,     A = 1 / 255				,     A = True				,     A = True				,     A = [0.48145466, 0.4578275, 0.40821073]				,     A = [0.26862954, 0.26130258, 0.27577711]				,     A = True				,     A=7				,     A=30				,     A=400				,     A=3				,     )					->  int:


						"""simple docstring"""



						_a											=						parent
						_a											=						do_resize
						_a											=						size if size is not None else {'''shortest_edge''': 288}
						_a											=						size_divisor
						_a											=						do_rescale
						_a											=						rescale_factor
						_a											=						do_normalize
						_a											=						do_center_crop
						_a											=						image_mean
						_a											=						image_std
						_a											=						do_pad
						_a											=						batch_size
						_a											=						num_channels
						_a											=						min_resolution
						_a											=						max_resolution



	def       a__						(self )					->  Optional[Any]:


						"""simple docstring"""



						return {
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						    "do_normalize": self.do_normalize,
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "size_divisor": self.size_divisor,
						}



	def       a__						(self				,     A				,     A=False )					->  Union[str, Any]:


						"""simple docstring"""



						if not batched:
											_a											=						self.size['''shortest_edge''']
											_a											=						image_inputs[0]
											if isinstance(A				,     Image.Image ):
																_a						,					_a											=						image.size
											else:
																_a						,					_a											=						image.shape[1], image.shape[2]
											_a											=						size / min(A				,     A )
											if h < w:
																_a						,					_a											=						size, scale * w
											else:
																_a						,					_a											=						scale * h, size

											_a											=						int((1_333 / 800) * size )
											if max(A				,     A ) > max_size:
																_a											=						max_size / max(A				,     A )
																_a											=						newh * scale
																_a											=						neww * scale

											_a						,					_a											=						int(newh + 0.5 ), int(neww + 0.5 )
											_a						,					_a											=						(
											    newh // self.size_divisor * self.size_divisor,
											    neww // self.size_divisor * self.size_divisor,
											)

						else:
											_a											=						[]
											for image in image_inputs:
																_a						,					_a											=						self.get_expected_values([image] )
																expected_values.append((expected_height, expected_width) )
											_a											=						max(A				,     key=lambda A : item[0] )[0]
											_a											=						max(A				,     key=lambda A : item[1] )[1]

						return expected_height, expected_width






@require_torch
@require_vision
class __A    (						A     ,     unittest.TestCase		):



	'''simple docstring'''







	__lowerCamelCase					: Any    = BridgeTowerImageProcessor if is_vision_available() else None



	def       a__						(self )					->  int:


						"""simple docstring"""



						_a											=						BridgeTowerImageProcessingTester(self )



	@property
	def       a__						(self )					->  Union[str, Any]:


						"""simple docstring"""



						return self.image_processor_tester.prepare_image_processor_dict()



	def       a__						(self )					->  Tuple:


						"""simple docstring"""



						_a											=						self.image_processing_class(**self.image_processor_dict )
						self.assertTrue(hasattr(A				,     '''image_mean''' ) )
						self.assertTrue(hasattr(A				,     '''image_std''' ) )
						self.assertTrue(hasattr(A				,     '''do_normalize''' ) )
						self.assertTrue(hasattr(A				,     '''do_resize''' ) )
						self.assertTrue(hasattr(A				,     '''size''' ) )
						self.assertTrue(hasattr(A				,     '''size_divisor''' ) )



	def       a__						(self )					->  Any:


						"""simple docstring"""



						pass



	def       a__						(self )					->  Any:


						"""simple docstring"""



						_a											=						self.image_processing_class(**self.image_processor_dict )
						# create random PIL images
						_a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A )
						for image in image_inputs:
											self.assertIsInstance(A				,     Image.Image )

						# Test not batched input
						_a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values

						_a						,					_a											=						self.image_processor_tester.get_expected_values(A )
						self.assertEqual(
						    encoded_images.shape				,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)				,     )

						# Test batched
						_a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values

						_a						,					_a											=						self.image_processor_tester.get_expected_values(A				,     batched=A )
						self.assertEqual(
						    encoded_images.shape				,     (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )				,     )



	def       a__						(self )					->  Tuple:


						"""simple docstring"""



						_a											=						self.image_processing_class(**self.image_processor_dict )
						# create random numpy tensors
						_a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A				,     numpify=A )
						for image in image_inputs:
											self.assertIsInstance(A				,     np.ndarray )

						# Test not batched input
						_a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values

						_a						,					_a											=						self.image_processor_tester.get_expected_values(A )
						self.assertEqual(
						    encoded_images.shape				,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)				,     )

						# Test batched
						_a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values

						_a						,					_a											=						self.image_processor_tester.get_expected_values(A				,     batched=A )
						self.assertEqual(
						    encoded_images.shape				,     (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )				,     )



	def       a__						(self )					->  Optional[int]:


						"""simple docstring"""



						_a											=						self.image_processing_class(**self.image_processor_dict )
						# create random PyTorch tensors
						_a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A				,     torchify=A )
						for image in image_inputs:
											self.assertIsInstance(A				,     torch.Tensor )

						# Test not batched input
						_a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values

						_a						,					_a											=						self.image_processor_tester.get_expected_values(A )
						self.assertEqual(
						    encoded_images.shape				,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)				,     )

						# Test batched
						_a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values

						_a						,					_a											=						self.image_processor_tester.get_expected_values(A				,     batched=A )
						self.assertEqual(
						    encoded_images.shape				,     (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )				,     )








'''simple docstring'''





def lowerCAmelCase						(__A = 1_000):



     """simple docstring"""



     _a											=						2**power
     _a											=						str(__A)
     _a											=						list(__A)
     _a											=						0

     for i in list_num:
          sum_of_num += int(__A)

     return sum_of_num


if __name__ == "__main__":
  lowercase_	 =						int(input("Enter the power of 2: ").strip())
  print("2 ^ ", power, " = ", 2**power)
  lowercase_	 =						solution(power)
  print("Sum of the digits is: ", result)



