





def  SCREAMING_SNAKE_CASE_		(    __A				:    int       )			->	Optional[Any]:

       """simple docstring"""

       if not isinstance(UpperCAmelCase__						,					UpperCAmelCase__       ):
              raise ValueError('multiplicative_persistence() only accepts integral values'       )
       if num < 0:
              raise ValueError('multiplicative_persistence() does not accept negative values'       )

       a_      :	Union[str, Any]							=						0
       a_      :	Tuple							=						str(UpperCAmelCase__       )

       while len(UpperCAmelCase__       ) != 1:
              a_      :	Dict							=						[int(UpperCAmelCase__       ) for i in num_string]

              a_      :	List[Any]							=						1
              for i in range(0						,					len(UpperCAmelCase__       )       ):
                     total *= numbers[i]

              a_      :	str							=						str(UpperCAmelCase__       )

              steps += 1
       return steps







def  SCREAMING_SNAKE_CASE_		(    __A				:    int       )			->	Dict:

       """simple docstring"""

       if not isinstance(UpperCAmelCase__						,					UpperCAmelCase__       ):
              raise ValueError('additive_persistence() only accepts integral values'       )
       if num < 0:
              raise ValueError('additive_persistence() does not accept negative values'       )

       a_      :	Union[str, Any]							=						0
       a_      :	Dict							=						str(UpperCAmelCase__       )

       while len(UpperCAmelCase__       ) != 1:
              a_      :	Union[str, Any]							=						[int(UpperCAmelCase__       ) for i in num_string]

              a_      :	Dict							=						0
              for i in range(0						,					len(UpperCAmelCase__       )       ):
                     total += numbers[i]

              a_      :	Union[str, Any]							=						str(UpperCAmelCase__       )

              steps += 1
       return steps


if __name__ == "__main__":
   import doctest

   doctest.testmod()






from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

UpperCAmelCase_   :				Dict						      = [
    'python',
    'tqdm',
    'regex',
    'requests',
    'packaging',
    'filelock',
    'numpy',
    'tokenizers',
    'huggingface-hub',
    'safetensors',
    'accelerate',
    'pyyaml',
]

for pkg in pkgs_to_check_at_runtime:
   if pkg in deps:
      if pkg == "tokenizers":
         # must be loaded here, or else tqdm check may fail
         from .utils import is_tokenizers_available

         if not is_tokenizers_available():
            continue  # not required, check version only if installed
      elif pkg == "accelerate":
         # must be loaded here, or else tqdm check may fail
         from .utils import is_accelerate_available

         # Maybe switch to is_torch_available in the future here so that Accelerate is hard dep of
         # Transformers with PyTorch
         if not is_accelerate_available():
            continue  # not required, check version only if installed

      require_version_core(deps[pkg])
   else:
      raise ValueError(F'can\'t find {pkg} in {deps.keys()}, check dependency_versions_table.py')







def  SCREAMING_SNAKE_CASE_		(    __A				:    Optional[Any]						,					__A				:    int=None       )			->	int:

       """simple docstring"""

       require_version(deps[pkg]						,					__A       )


