

lowerCamelCase_					  =   (1, 153, 370, 371, 1634, 24678051, 115132219018763992565095597973971522401)
lowerCamelCase_					  =   (-153, -1, 0, 1.2, 200, "A", [], {}, None)



def   UpperCamelCase(   lowercase_				)      ->							bool:





  '''simple docstring'''





  if not isinstance(lowercase_     ,   lowercase_				) or n < 1:
    return False

  # Initialization of sum and number of digits.
  snake_case_					= 0
  snake_case_					= 0
  snake_case_					= 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
  snake_case_					= n
  while temp > 0:
    snake_case_					= temp % 10
    total += rem**number_of_digits
    temp //= 10
  return n == total



def   UpperCamelCase(   lowercase_				)      ->							bool:





  '''simple docstring'''





  if not isinstance(lowercase_     ,   lowercase_				) or n < 1:
    return False

  # Init a "histogram" of the digits
  snake_case_					= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  snake_case_					= 0
  snake_case_					= 0
  snake_case_					= n
  while temp > 0:
    snake_case_		,							snake_case_					= divmod(lowercase_     ,   10				)
    digit_histogram[rem] += 1
    digit_total += 1

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

  return n == total



def   UpperCamelCase(   lowercase_				)      ->							bool:





  '''simple docstring'''





  if not isinstance(lowercase_     ,   lowercase_				) or n < 1:
    return False
  snake_case_					= len(str(lowercase_				)				)  # 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(lowercase_				) ** expo for i in str(lowercase_				)				)



def   UpperCamelCase(   )      ->							str:





  '''simple docstring'''





  snake_case_					= int(input("""Enter an integer to see if it is an Armstrong number: """				).strip()				)
  print(f'''{num} is {"" if armstrong_number(lowercase_				) else "not "}an Armstrong number.'''				)
  print(f'''{num} is {"" if narcissistic_number(lowercase_				) else "not "}an Armstrong number.'''				)
  print(f'''{num} is {"" if pluperfect_number(lowercase_				) else "not "}an Armstrong number.'''				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()


import unittest

from diffusers import __version__
from diffusers.utils import deprecate







class 					__lowerCamelCase							(      unittest.TestCase      ):
      lowerCamelCase_      : Dict  			=   '.'.join([str(int(__version__.split('.'      )[0]      ) + 1      )] + __version__.split('.'      )[1:]      )
      lowerCamelCase_      : int  			=   '0.0.1'







      def       lowerCAmelCase_       (	self  )		->			Optional[int]:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate("""deprecated_arg"""				,    self.higher_version				,    """message"""				,    take_from=lowerCamelCase  )

        assert output == 4
        assert (
            str(warning.warning  )
            == f'''The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}.'''
            " message"
        )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(("""deprecated_arg""", self.higher_version, """message""")				,    take_from=lowerCamelCase  )

        assert output == 4
        assert (
            str(warning.warning  )
            == f'''The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}.'''
            " message"
        )







      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= {"""deprecated_arg_1""": 4, """deprecated_arg_2""": 8}
        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_		,							snake_case_					= deprecate(
              ("""deprecated_arg_1""", self.higher_version, """Hey""")				,    ("""deprecated_arg_2""", self.higher_version, """Hey""")				,    take_from=lowerCamelCase				,    )
        assert output_a == 4
        assert output_a == 8
        assert (
            str(warning.warnings[0].message  )
            == "The `deprecated_arg_1` argument is deprecated and will be removed in version"
            f''' {self.higher_version}. Hey'''
        )
        assert (
            str(warning.warnings[1].message  )
            == "The `deprecated_arg_2` argument is deprecated and will be removed in version"
            f''' {self.higher_version}. Hey'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertRaises(lowerCamelCase  ) as error:
          deprecate(("""wrong_arg""", self.higher_version, """message""")				,    take_from=lowerCamelCase  )

        assert "test_deprecate_function_incorrect_arg in" in str(error.exception  )
        assert "line" in str(error.exception  )
        assert "got an unexpected keyword argument `deprecated_arg`" in str(error.exception  )







      def       lowerCAmelCase_       (	self  )		->			Optional[Any]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """message""")  )

        assert (
            str(warning.warning  )
            == f'''`deprecated_arg` is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(
              ("""deprecated_arg_1""", self.higher_version, """Hey""")				,    ("""deprecated_arg_2""", self.higher_version, """Hey""")				,    )
        assert (
            str(warning.warnings[0].message  )
            == f'''`deprecated_arg_1` is deprecated and will be removed in version {self.higher_version}. Hey'''
        )
        assert (
            str(warning.warnings[1].message  )
            == f'''`deprecated_arg_2` is deprecated and will be removed in version {self.higher_version}. Hey'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:







        class 					__lowerCamelCase							:
              lowerCamelCase_      : Dict  			=   5

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(("""arg""", self.higher_version, """message""")				,    take_from=Args()  )

        assert arg == 5
        assert (
            str(warning.warning  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:







        class 					__lowerCamelCase							:
              lowerCamelCase_      : str  			=   5
              lowerCamelCase_      : List[str]  			=   7

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_		,							snake_case_					= deprecate(
              ("""arg""", self.higher_version, """message""")				,    ("""foo""", self.higher_version, """message""")				,    ("""does not exist""", self.higher_version, """message""")				,    take_from=Args()				,    )

        assert arg_a == 5
        assert arg_a == 7
        assert (
            str(warning.warning  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )
        assert (
            str(warning.warnings[0].message  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )
        assert (
            str(warning.warnings[1].message  )
            == f'''The `foo` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= {"""deprecated_arg""": 4}

        with self.assertRaises(lowerCamelCase  ) as error:
          deprecate(("""wrong_arg""", self.lower_version, """message""")				,    take_from=lowerCamelCase  )

        assert (
            str(error.exception  )
            == "The deprecation tuple ('wrong_arg', '0.0.1', 'message') should be removed since diffusers' version"
            f''' {__version__} is >= {self.lower_version}'''
        )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """This message is better!!!""")				,    standard_warn=lowerCamelCase  )

        assert str(warning.warning  ) == "This message is better!!!"







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """This message is better!!!""")				,    standard_warn=lowerCamelCase  )
        assert str(warning.warning  ) == "This message is better!!!"
        assert "diffusers/tests/others/test_utils.py" in warning.filename