


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			:							int       					=			1_0000
 __lowercase			:							Optional[List[str]]       					=			None
 __lowercase			:							Optional[datasets.Features]       					=			None





class   __a      (   datasets.ArrowBasedBuilder				):
 __lowercase			:							Optional[Any]       					=			ParquetConfig
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Dict:




        '''simple docstring'''
        return datasets.DatasetInfo(features=self.config.features			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    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}'			)
        lowercase__:       List[Any]        =       dl_manager.download_and_extract(self.config.data_files			)
        if isinstance(lowerCAmelCase__    ,			(str, list, tuple)			):
               lowercase__:       Union[str, Any]        =       data_files
               if isinstance(lowerCAmelCase__    ,			lowerCAmelCase__			):
                      lowercase__:       List[Any]        =       [files]
               # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
               lowercase__:       Union[str, Any]        =       [dl_manager.iter_files(lowerCAmelCase__			) for file in files]
               return [datasets.SplitGenerator(name=datasets.Split.TRAIN    ,			gen_kwargs={'files': files}			)]
        lowercase__:       Tuple        =       []
        for split_name, files in data_files.items():
               if isinstance(lowerCAmelCase__    ,			lowerCAmelCase__			):
                      lowercase__:       int        =       [files]
               # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
               lowercase__:       int        =       [dl_manager.iter_files(lowerCAmelCase__			) 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(lowerCAmelCase__			):
                             with open(lowerCAmelCase__    ,			'rb'			) as f:
                                    lowercase__:       Any        =       datasets.Features.from_arrow_schema(pq.read_schema(lowerCAmelCase__			)			)
                             break
               splits.append(datasets.SplitGenerator(name=lowerCAmelCase__    ,			gen_kwargs={'files': files}			)			)
        return splits
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    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
               lowercase__:       List[Any]        =       table_cast(lowerCAmelCase__    ,			self.info.features.arrow_schema			)
        return pa_table
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    Any:




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






from __future__ import annotations




def        snake_case_					(  snake_case      ,							snake_case					)  ->    list[int]:
       lowercase__:       Tuple        =       0
       lowercase__:       str        =       len(snake_case					) - 1

       while i < j:
              if nums[i] + nums[j] == target:
                     return [i, j]
              elif nums[i] + nums[j] < target:
                     lowercase__:       str        =       i + 1
              else:
                     lowercase__:       Dict        =       j - 1

       return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F'''{two_pointer([2, 7, 11, 15], 9) = }''')


