

"""simple docstring"""






lowerCamelCase__				:  Any													=  (1, 1_53, 3_70, 3_71, 16_34, 24_67_80_51, 1_15_13_22_19_01_87_63_99_25_65_09_55_97_97_39_71_52_24_01)
lowerCamelCase__				:  tuple													=  (-1_53, -1, 0, 1.2, 2_00, "A", [], {}, None)
def       UpperCamelCase					(			_lowerCAmelCase     :						int )				->			bool:
	if not isinstance(_lowerCAmelCase,  _lowerCAmelCase ) or n < 1:
		return False

	# Initialization of sum and number of digits.
	_UpperCAmelCase    :							Optional[Any]									=					0
	_UpperCAmelCase    :							Union[str, Any]									=					0
	_UpperCAmelCase    :							Union[str, Any]									=					n
	# Calculation of digits of the number
	while temp > 0:
		number_of_digits += 1
		temp //= 10
	# Dividing number into separate digits and find Armstrong number
	_UpperCAmelCase    :							Union[str, Any]									=					n
	while temp > 0:
		_UpperCAmelCase    :							int									=					temp % 10
		total += rem**number_of_digits
		temp //= 10
	return n == total
def       UpperCamelCase					(			_lowerCAmelCase     :						int )				->			bool:
	if not isinstance(_lowerCAmelCase,  _lowerCAmelCase ) or n < 1:
		return False

	# Init a "histogram" of the digits
	_UpperCAmelCase    :							Optional[int]									=					[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
	_UpperCAmelCase    :							List[Any]									=					0
	_UpperCAmelCase    :							Tuple									=					0
	_UpperCAmelCase    :							Union[str, Any]									=					n
	while temp > 0:
		_UpperCAmelCase    :							Union[str, Any]									=					divmod(_lowerCAmelCase,  10 )
		digit_histogram[rem] += 1
		digit_total += 1

	for cnt, i in zip(_lowerCAmelCase,  range(len(_lowerCAmelCase ) ) ):
		total += cnt * i**digit_total

	return n == total
def       UpperCamelCase					(			_lowerCAmelCase     :						int )				->			bool:
	if not isinstance(_lowerCAmelCase,  _lowerCAmelCase ) or n < 1:
		return False
	_UpperCAmelCase    :							List[Any]									=					len(str(_lowerCAmelCase ) )  # the power that all digits will be raised to
	# check if sum of each digit multiplied expo times is equal to number
	return n == sum(int(_lowerCAmelCase ) ** expo for i in str(_lowerCAmelCase ) )
def       UpperCamelCase					(			)				->			Optional[int]:
	_UpperCAmelCase    :							Union[str, Any]									=					int(input("""Enter an integer to see if it is an Armstrong number: """ ).strip() )
	print(f'''{num} is {"" if armstrong_number(_lowerCAmelCase ) else "not "}an Armstrong number.''' )
	print(f'''{num} is {"" if narcissistic_number(_lowerCAmelCase ) else "not "}an Armstrong number.''' )
	print(f'''{num} is {"" if pluperfect_number(_lowerCAmelCase ) else "not "}an Armstrong number.''' )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()








"""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 ViTImageProcessor






class     _UpperCAmelCase			(		unittest.TestCase):
			def __init__(		self      ,		_A      ,		_A=7      ,		_A=3      ,		_A=18      ,		_A=30      ,		_A=4_00      ,		_A=True      ,		_A=None      ,		_A=True      ,		_A=[0.5, 0.5, 0.5]      ,		_A=[0.5, 0.5, 0.5]      ,		)    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[Any]									=					size if size is not None else {"""height""": 18, """width""": 18}
				_UpperCAmelCase    :							Tuple									=					parent
				_UpperCAmelCase    :							Tuple									=					batch_size
				_UpperCAmelCase    :							Optional[int]									=					num_channels
				_UpperCAmelCase    :							Any									=					image_size
				_UpperCAmelCase    :							str									=					min_resolution
				_UpperCAmelCase    :							Dict									=					max_resolution
				_UpperCAmelCase    :							Optional[Any]									=					do_resize
				_UpperCAmelCase    :							str									=					size
				_UpperCAmelCase    :							Optional[int]									=					do_normalize
				_UpperCAmelCase    :							Optional[Any]									=					image_mean
				_UpperCAmelCase    :							Any									=					image_std
			def 							__snake_case (		self     )    ->    List[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,
				}






@require_torch
@require_vision
class     _UpperCAmelCase			(		__a    ,     unittest.TestCase):
			__a :       List[str]									=							ViTImageProcessor if is_vision_available() else None
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				_UpperCAmelCase    :							Tuple									=					ViTImageProcessingTester(self     )
			@property
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				return self.image_processor_tester.prepare_image_processor_dict()
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					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"""     )     )
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					self.image_processing_class.from_dict(self.image_processor_dict     )
				self.assertEqual(image_processor.size      ,		{"""height""": 18, """width""": 18}     )

				_UpperCAmelCase    :							Any									=					self.image_processing_class.from_dict(self.image_processor_dict      ,		size=42     )
				self.assertEqual(image_processor.size      ,		{"""height""": 42, """width""": 42}     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				pass
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







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

				# Test not batched input
				_UpperCAmelCase    :							Optional[Any]									=					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.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)

				# Test batched
				_UpperCAmelCase    :							Union[str, Any]									=					image_processing(_A      ,		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.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					self.image_processing_class(**self.image_processor_dict     )
				# create random numpy tensors
				_UpperCAmelCase    :							List[Any]									=					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
				_UpperCAmelCase    :							Any									=					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.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)

				# Test batched
				_UpperCAmelCase    :							int									=					image_processing(_A      ,		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.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					self.image_processing_class(**self.image_processor_dict     )
				# create random PyTorch tensors
				_UpperCAmelCase    :							Tuple									=					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
				_UpperCAmelCase    :							Optional[int]									=					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.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)

				# Test batched
				_UpperCAmelCase    :							Tuple									=					image_processing(_A      ,		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.size["""height"""],
				        self.image_processor_tester.size["""width"""],
				    )      ,		)





