






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       snake_case__ (				datasets.BuilderConfig):

       '''simple docstring'''
       lowerCamelCase				:					int								=			1_0000
       lowerCamelCase				:					Optional[List[str]]								=			None
       lowerCamelCase				:					Optional[datasets.Features]								=			None




class       snake_case__ (				datasets.ArrowBasedBuilder):

       '''simple docstring'''
       lowerCamelCase				:					Optional[int]								=			ParquetConfig



       def        __lowercase    (				self     )			->   int:






            '''simple docstring'''





            return datasets.DatasetInfo(features=self.config.features     )



       def        __lowercase    (				self      ,    a__     )			->   Optional[Any]:






            '''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}'''     )
            __snake_case      :List[Any] 							=    dl_manager.download_and_extract(self.config.data_files     )
            if isinstance(a__      ,    (str, list, tuple)     ):
                 __snake_case      :str 							=    data_files
                 if isinstance(a__      ,    a__     ):
                      __snake_case      :List[Any] 							=    [files]
                 # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
                 __snake_case      :int 							=    [dl_manager.iter_files(a__     ) for file in files]
                 return [datasets.SplitGenerator(name=datasets.Split.TRAIN      ,    gen_kwargs={"""files""": files}     )]
            __snake_case      :Any 							=    []
            for split_name, files in data_files.items():
                 if isinstance(a__      ,    a__     ):
                      __snake_case      :Dict 							=    [files]
                 # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
                 __snake_case      :str 							=    [dl_manager.iter_files(a__     ) 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(a__     ):
                           with open(a__      ,    """rb"""     ) as f:
                                __snake_case      :Optional[int] 							=    datasets.Features.from_arrow_schema(pq.read_schema(a__     )     )
                           break
                 splits.append(datasets.SplitGenerator(name=a__      ,    gen_kwargs={"""files""": files}     )     )
            return splits



       def        __lowercase    (				self      ,    a__     )			->   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
                 __snake_case      :str 							=    table_cast(a__      ,    self.info.features.arrow_schema     )
            return pa_table



       def        __lowercase    (				self      ,    a__     )			->   Any:






            '''simple docstring'''





            __snake_case      :Optional[Any] 							=    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(a__     )     ):
                 with open(a__      ,    """rb"""     ) as f:
                      __snake_case      :Dict 							=    pq.ParquetFile(a__     )
                      try:
                           for batch_idx, record_batch in enumerate(
                               parquet_file.iter_batches(batch_size=self.config.batch_size      ,    columns=self.config.columns     )     ):
                                __snake_case      :Union[str, Any] 							=    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(a__     )
                      except ValueError as e:
                           logger.error(F'''Failed to read file \'{file}\' with error {type(a__     )}: {e}'''     )
                           raise










def 	UpperCamelCase	(							snake_case__  : list	):




     '''simple docstring'''






     if not grid or not grid[0]:
          raise TypeError("""The grid does not contain the appropriate information"""	)

     for cell_n in range(1						,len(grid[0]	)	):
          grid[0][cell_n] += grid[0][cell_n - 1]
     __snake_case      :str 							=    grid[0]

     for row_n in range(1						,len(snake_case__	)	):
          __snake_case      :Optional[int] 							=    grid[row_n]
          __snake_case      :Optional[Any] 							=    fill_row(snake_case__						,snake_case__	)
          __snake_case      :Dict 							=    grid[row_n]

     return grid[-1][-1]






def 	UpperCamelCase	(							snake_case__  : list						,snake_case__  : list	):




     '''simple docstring'''






     current_row[0] += row_above[0]
     for cell_n in range(1						,len(snake_case__	)	):
          current_row[cell_n] += min(current_row[cell_n - 1]						,row_above[cell_n]	)

     return current_row


if __name__ == "__main__":
     import doctest

     doctest.testmod()


