





"""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


__UpperCamelCase     :						Union[str, Any]						       =  datasets.utils.logging.get_logger(__name__)







@dataclass
class       a							(   datasets.BuilderConfig  ):
 snake_case__             =       1_0_0_0_0
 snake_case__             =       None
 snake_case__             =       None







class       a							(   datasets.ArrowBasedBuilder  ):
 snake_case__             =       ParquetConfig



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self				,       _snake_case     ):







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



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """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
   lowerCAmelCase    				= table_cast(_snake_case				,       self.info.features.arrow_schema     )
  return pa_table



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






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







from collections.abc import Sequence
def 							SCREAMING_SNAKE_CASE_	(					UpperCAmelCase_	:     Sequence[int] | None = None				)			->						int:
       if nums is None or not nums:
              raise ValueError('''Input sequence should not be empty'''				)

       SCREAMING_SNAKE_CASE_							:				Tuple		=nums[0]
       for i in range(1			,							len(UpperCAmelCase_				)				):
              SCREAMING_SNAKE_CASE_							:				Any		=nums[i]
              SCREAMING_SNAKE_CASE_							:				Optional[int]		=max(UpperCAmelCase_			,							ans + num			,							UpperCAmelCase_				)

       return ans


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 # Try on a sample input from the user
 _lowercase											=    int(input("""Enter number of elements : """).strip())
 _lowercase											=    list(map(int, input("""\nEnter the numbers : """).strip().split()))[:n]
 print(max_subsequence_sum(array))
