


from math import pow





def __UpperCAmelCase       (		__A ,						__A ,						__A ,						__A ,						__A ,						)						->					tuple[int, int]:



       '''simple docstring'''





       if current_sum == needed_sum:
              # If the sum of the powers is equal to needed_sum, then we have a solution.
              solutions_count += 1
              return current_sum, solutions_count

       UpperCAmelCase__										=     int(pow(__A ,						__A			)			)
       if current_sum + i_to_n <= needed_sum:
              # If the sum of the powers is less than needed_sum, then continue adding powers.
              current_sum += i_to_n
              UpperCAmelCase__						,			UpperCAmelCase__										=     backtrack(
                  __A ,						__A ,						current_number + 1 ,						__A ,						__A			)
              current_sum -= i_to_n
       if i_to_n < needed_sum:
              # If the power of i is less than needed_sum, then try with the next power.
              UpperCAmelCase__						,			UpperCAmelCase__										=     backtrack(
                  __A ,						__A ,						current_number + 1 ,						__A ,						__A			)
       return current_sum, solutions_count





def __UpperCAmelCase       (		__A ,						__A			)						->					int:



       '''simple docstring'''





       if not (1 <= needed_sum <= 1_0_0_0 and 2 <= power <= 1_0):
              raise ValueError(
                  "Invalid input\n"
                  "needed_sum must be between 1 and 1000, power between 2 and 10."			)

       return backtrack(__A ,						__A ,						1 ,						0 ,						0			)[1]  # Return the solutions_count


if __name__ == "__main__":
    import doctest

    doctest.testmod()









import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs


class     lowercase__  (					__SCREAMING_SNAKE_CASE		):






  def __init__(					self      :					Dict		,						_lowercase      :					int		,						_lowercase      :					List[Any]=None		,						_lowercase      :					str=True		,						_lowercase      :					str=None		,						**_lowercase      :					Optional[int] ):




         """simple docstring"""







         UpperCAmelCase__										=     parent
         UpperCAmelCase__										=     config_class
         UpperCAmelCase__										=     has_text_modality
         UpperCAmelCase__										=     kwargs
         UpperCAmelCase__										=     common_properties






  def 			_UpperCAmelCase  (					self      :					Dict ):




         """simple docstring"""







         UpperCAmelCase__										=     self.config_class(**self.inputs_dict )
         UpperCAmelCase__										=     (
             ["hidden_size", "num_attention_heads", "num_hidden_layers"]
             if self.common_properties is None
             else self.common_properties
         )

         # Add common fields for text models
         if self.has_text_modality:
                common_properties.extend(["vocab_size"] )

         # Test that config has the common properties as getters
         for prop in common_properties:
                self.parent.assertTrue(hasattr(_lowercase		,						_lowercase )		,						msg=F"""`{prop}` does not exist""" )

         # Test that config has the common properties as setter
         for idx, name in enumerate(_lowercase ):
                try:
                       setattr(_lowercase		,						_lowercase		,						_lowercase )
                       self.parent.assertEqual(
                           getattr(_lowercase		,						_lowercase )		,						_lowercase		,						msg=F"""`{name} value {idx} expected, but was {getattr(_lowercase		,						_lowercase )}""" )
                except NotImplementedError:
                       # Some models might not be able to implement setters for common_properties
                       # In that case, a NotImplementedError is raised
                       pass

        # Test if config class can be called with Config(prop_name=..)
         for idx, name in enumerate(_lowercase ):
                try:
                       UpperCAmelCase__										=     self.config_class(**{name: idx} )
                       self.parent.assertEqual(
                           getattr(_lowercase		,						_lowercase )		,						_lowercase		,						msg=F"""`{name} value {idx} expected, but was {getattr(_lowercase		,						_lowercase )}""" )
                except NotImplementedError:
                       # Some models might not be able to implement setters for common_properties
                       # In that case, a NotImplementedError is raised
                       pass






  def 			_UpperCAmelCase  (					self      :					int ):




         """simple docstring"""







         UpperCAmelCase__										=     self.config_class(**self.inputs_dict )
         UpperCAmelCase__										=     json.loads(config.to_json_string() )
         for key, value in self.inputs_dict.items():
                self.parent.assertEqual(obj[key]		,						_lowercase )






  def 			_UpperCAmelCase  (					self      :					Optional[int] ):




         """simple docstring"""







         UpperCAmelCase__										=     self.config_class(**self.inputs_dict )

         with tempfile.TemporaryDirectory() as tmpdirname:
                UpperCAmelCase__										=     os.path.join(_lowercase		,						"config.json" )
                config_first.to_json_file(_lowercase )
                UpperCAmelCase__										=     self.config_class.from_json_file(_lowercase )

         self.parent.assertEqual(config_second.to_dict()		,						config_first.to_dict() )






  def 			_UpperCAmelCase  (					self      :					Optional[int] ):




         """simple docstring"""







         UpperCAmelCase__										=     self.config_class(**self.inputs_dict )

         with tempfile.TemporaryDirectory() as tmpdirname:
                config_first.save_pretrained(_lowercase )
                UpperCAmelCase__										=     self.config_class.from_pretrained(_lowercase )

         self.parent.assertEqual(config_second.to_dict()		,						config_first.to_dict() )






  def 			_UpperCAmelCase  (					self      :					List[str] ):




         """simple docstring"""







         UpperCAmelCase__										=     self.config_class(**self.inputs_dict )

         UpperCAmelCase__										=     "test"
         with tempfile.TemporaryDirectory() as tmpdirname:
                UpperCAmelCase__										=     os.path.join(_lowercase		,						_lowercase )
                config_first.save_pretrained(_lowercase )
                UpperCAmelCase__										=     self.config_class.from_pretrained(_lowercase		,						subfolder=_lowercase )

         self.parent.assertEqual(config_second.to_dict()		,						config_first.to_dict() )






  def 			_UpperCAmelCase  (					self      :					List[str] ):




         """simple docstring"""







         UpperCAmelCase__										=     self.config_class(**self.inputs_dict		,						num_labels=5 )
         self.parent.assertEqual(len(config.idalabel )		,						5 )
         self.parent.assertEqual(len(config.labelaid )		,						5 )

         UpperCAmelCase__										=     3
         self.parent.assertEqual(len(config.idalabel )		,						3 )
         self.parent.assertEqual(len(config.labelaid )		,						3 )






  def 			_UpperCAmelCase  (					self      :					Any ):




         """simple docstring"""







         if self.config_class.is_composition:
                return
         UpperCAmelCase__										=     self.config_class()
         self.parent.assertIsNotNone(_lowercase )






  def 			_UpperCAmelCase  (					self      :					Any ):




         """simple docstring"""







         UpperCAmelCase__										=     copy.deepcopy(_lowercase )
         UpperCAmelCase__										=     self.config_class(**_lowercase )
         UpperCAmelCase__										=     []
         for key, value in config_common_kwargs.items():
                if key == "torch_dtype":
                       if not is_torch_available():
                              continue
                       else:
                              import torch

                              if config.torch_dtype != torch.floataa:
                                     wrong_values.append(("torch_dtype", config.torch_dtype, torch.floataa) )
                elif getattr(_lowercase		,						_lowercase ) != value:
                       wrong_values.append((key, getattr(_lowercase		,						_lowercase ), value) )

         if len(_lowercase ) > 0:
                UpperCAmelCase__										=     "\n".join([F"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values] )
                raise ValueError(F"""The following keys were not properly set in the config:\n{errors}""" )






  def 			_UpperCAmelCase  (					self      :					Any ):




         """simple docstring"""







         self.create_and_test_config_common_properties()
         self.create_and_test_config_to_json_string()
         self.create_and_test_config_to_json_file()
         self.create_and_test_config_from_and_save_pretrained()
         self.create_and_test_config_from_and_save_pretrained_subfolder()
         self.create_and_test_config_with_num_labels()
         self.check_config_can_be_init_without_params()
         self.check_config_arguments_init()





