

'''simple docstring'''







import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


__lowerCamelCase						    =      datasets.utils.logging.get_logger(__name__)


@dataclass
class    A__ ( datasets.BuilderConfig     ):
    lowercase		   =						10_000
    lowercase		   =						None
    lowercase		   =						None


class    A__ ( datasets.ArrowBasedBuilder     ):
    lowercase		   =						ParquetConfig



    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           return datasets.DatasetInfo(features=self.config.features    )



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> Optional[int]:





           '''simple docstring'''
           if not self.config.data_files:
                  raise ValueError(f'''At least one data file must be specified, but got data_files={self.config.data_files}'''    )
           A_		   = dl_manager.download_and_extract(self.config.data_files    )
           if isinstance(UpperCamelCase__						,			(str, list, tuple)    ):
                  A_		   = data_files
                  if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                         A_		   = [files]
                  # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
                  A_		   = [dl_manager.iter_files(UpperCamelCase__    ) for file in files]
                  return [datasets.SplitGenerator(name=datasets.Split.TRAIN						,			gen_kwargs={"""files""": files}    )]
           A_		   = []
           for split_name, files in data_files.items():
                  if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                         A_		   = [files]
                  # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
                  A_		   = [dl_manager.iter_files(UpperCamelCase__    ) for file in files]
                  # Infer features is they are stoed in the arrow schema
                  if self.info.features is None:
                         for file in itertools.chain.from_iterable(UpperCamelCase__    ):
                                with open(UpperCamelCase__						,			"""rb"""    ) as f:
                                       A_		   = datasets.Features.from_arrow_schema(pq.read_schema(UpperCamelCase__    )    )
                                break
                  splits.append(datasets.SplitGenerator(name=UpperCamelCase__						,			gen_kwargs={"""files""": files}    )    )
           return splits



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> pa.Table:





           '''simple docstring'''
           if self.info.features is not None:
                  # more expensive cast to support nested features with keys in a different order
                  # allows str <-> int/float or str to Audio for example
                  A_		   = table_cast(UpperCamelCase__						,			self.info.features.arrow_schema    )
           return pa_table







    def    snake_case_     (   self						,			UpperCamelCase__    )  -> Dict:





           '''simple docstring'''
           A_		   = self.info.features.arrow_schema if self.info.features is not None else None
           if self.info.features is not None and self.config.columns is not None:
                  if sorted(field.name for field in schema    ) != sorted(self.config.columns    ):
                         raise ValueError(
                             f'''Tried to load parquet data with columns \'{self.config.columns}\' with mismatching features \'{self.info.features}\''''    )
           for file_idx, file in enumerate(itertools.chain.from_iterable(UpperCamelCase__    )    ):
                  with open(UpperCamelCase__						,			"""rb"""    ) as f:
                         A_		   = pq.ParquetFile(UpperCamelCase__    )
                         try:
                                for batch_idx, record_batch in enumerate(
                                    parquet_file.iter_batches(batch_size=self.config.batch_size						,			columns=self.config.columns    )    ):
                                       A_		   = pa.Table.from_batches([record_batch]    )
                                       # Uncomment for debugging (will print the Arrow table size and elements)
                                       # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                                       # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                       yield f'''{file_idx}_{batch_idx}''', self._cast_table(UpperCamelCase__    )
                         except ValueError as e:
                                logger.error(f'''Failed to read file \'{file}\' with error {type(UpperCamelCase__    )}: {e}'''    )
                                raise



'''simple docstring'''







import math
import sys
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     int:
       if number != int(UpperCAmelCase__			):
              raise ValueError("""the value of input must be a natural number"""			)
       if number < 0:
              raise ValueError("""the value of input must not be a negative number"""			)
       if number == 0:
              return 1
       A_		   = [-1] * (number + 1)
       A_		   = 0
       for i in range(1,    number + 1			):
              A_		   = sys.maxsize
              A_		   = int(math.sqrt(UpperCAmelCase__			)			)
              for j in range(1,    root + 1			):
                     A_		   = 1 + answers[i - (j**2)]
                     A_		   = min(UpperCAmelCase__,    UpperCAmelCase__			)
              A_		   = answer
       return answers[number]


if __name__ == "__main__":
      import doctest

      doctest.testmod()
