





"""simple docstring"""





from typing import Optional

import pyspark

from .. import Features, NamedSplit
from ..download import DownloadMode
from ..packaged_modules.spark.spark import Spark
from .abc import AbstractDatasetReader






class    _lowerCAmelCase  (	a			):
       """simple docstring"""




       def __init__(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase = None       ,					__UpperCAmelCase = None       ,					__UpperCAmelCase = True       ,					__UpperCAmelCase = None       ,					__UpperCAmelCase = False       ,					__UpperCAmelCase = None       ,					__UpperCAmelCase = True       ,					__UpperCAmelCase = "arrow"       ,					**__UpperCAmelCase       ,					):



         '''simple docstring'''

         super().__init__(
             split=__UpperCAmelCase       ,					features=__UpperCAmelCase       ,					cache_dir=__UpperCAmelCase       ,					keep_in_memory=__UpperCAmelCase       ,					streaming=__UpperCAmelCase       ,					**__UpperCAmelCase       ,					)
         lowerCAmelCase__     :Dict											=				load_from_cache_file
         lowerCAmelCase__     :int											=				file_format
         lowerCAmelCase__     :int											=				Spark(
             df=__UpperCAmelCase       ,					features=__UpperCAmelCase       ,					cache_dir=__UpperCAmelCase       ,					working_dir=__UpperCAmelCase       ,					**__UpperCAmelCase       ,					)






       def 	snake_case		(       self ):



         '''simple docstring'''

         if self.streaming:
           return self.builder.as_streaming_dataset(split=self.split )
         lowerCAmelCase__     :Dict											=				None if self._load_from_cache_file else DownloadMode.FORCE_REDOWNLOAD
         self.builder.download_and_prepare(
             download_mode=__UpperCAmelCase       ,					file_format=self._file_format       ,					)
         return self.builder.as_dataset(split=self.split )




'''simple docstring'''






from math import factorial

__A   :    dict[str, int]											= {str(digit): factorial(digit) for digit in range(10)}







def 							UpperCamelCase_     (       A__   :  int   ):
  '''simple docstring'''





  if not isinstance(A__				,       A__   ):
    raise TypeError("""Parameter number must be int"""   )

  if number < 0:
    raise ValueError("""Parameter number must be greater than or equal to 0"""   )

  # Converts number in string to iterate on its digits and adds its factorial.
  return sum(DIGIT_FACTORIAL[digit] for digit in str(A__   )   )







def 							UpperCamelCase_     (       A__   :  int = 60				,       A__   :  int = 1_00_00_00   ):
  '''simple docstring'''





  if not isinstance(A__				,       A__   ) or not isinstance(A__				,       A__   ):
    raise TypeError("""Parameters chain_length and number_limit must be int"""   )

  if chain_length <= 0 or number_limit <= 0:
    raise ValueError(
        """Parameters chain_length and number_limit must be greater than 0"""   )

  # the counter for the chains with the exact desired length
  lowerCAmelCase_     : Optional[int]     =  0
  # the cached sizes of the previous chains
  lowerCAmelCase_     : dict[int, int]     =  {}

  for start_chain_element in range(1				,       A__   ):
    # The temporary set will contain the elements of the chain
    lowerCAmelCase_     : List[str]     =  set()
    lowerCAmelCase_     : Optional[int]     =  0

    # Stop computing the chain when you find a cached size, a repeating item or the
    # length is greater then the desired one.
    lowerCAmelCase_     : int     =  start_chain_element
    while (
        chain_element not in chain_sets_lengths
        and chain_element not in chain_set
        and chain_set_length <= chain_length
    ):
      chain_set.add(A__   )
      chain_set_length += 1
      lowerCAmelCase_     : Union[str, Any]     =  digit_factorial_sum(A__   )

    if chain_element in chain_sets_lengths:
      chain_set_length += chain_sets_lengths[chain_element]

    lowerCAmelCase_     : int     =  chain_set_length

    # If chain contains the exact amount of elements increase the counter
    if chain_set_length == chain_length:
      chains_counter += 1

  return chains_counter


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  print(F'''{solution()}''')



