


import io
import itertools
import json
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa
import pyarrow.json as paj

import datasets
from datasets.table import table_cast
from datasets.utils.file_utils import readline


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







@dataclass
class        lowerCamelCase__	(							datasets.BuilderConfig      ):






			"""simple docstring"""






			_UpperCamelCase		:					Optional[datasets.Features]    =		None
			_UpperCamelCase		:					str    =		"utf-8"
			_UpperCamelCase		:					Optional[str]    =		None
			_UpperCamelCase		:					Optional[str]    =		None
			_UpperCamelCase		:					bool    =		True  # deprecated
			_UpperCamelCase		:					Optional[int]    =		None  # deprecated
			_UpperCamelCase		:					int    =		10 << 20  # 10MB
			_UpperCamelCase		:					Optional[bool]    =		None







class        lowerCamelCase__	(							datasets.ArrowBasedBuilder      ):






			"""simple docstring"""






			_UpperCamelCase		:					List[Any]    =		JsonConfig




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						if self.config.block_size is not None:
									logger.warning("The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead"     )
									UpperCamelCase__					=       self.config.block_size
						if self.config.use_threads is not True:
									logger.warning(
									    "The JSON loader parameter `use_threads` is deprecated and doesn\'t have any effect anymore."     )
						if self.config.newlines_in_values is not None:
									raise ValueError("The JSON loader parameter `newlines_in_values` is no longer supported"     )
						return datasets.DatasetInfo(features=self.config.features     )




			def 				snake_case__				(							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}'''     )
						UpperCamelCase__					=       dl_manager.download_and_extract(self.config.data_files     )
						if isinstance(UpperCamelCase__      ,						(str, list, tuple)     ):
									UpperCamelCase__					=       data_files
									if isinstance(UpperCamelCase__      ,						UpperCamelCase__     ):
												UpperCamelCase__					=       [files]
									UpperCamelCase__					=       [dl_manager.iter_files(UpperCamelCase__     ) for file in files]
									return [datasets.SplitGenerator(name=datasets.Split.TRAIN      ,						gen_kwargs={"files": files}     )]
						UpperCamelCase__					=       []
						for split_name, files in data_files.items():
									if isinstance(UpperCamelCase__      ,						UpperCamelCase__     ):
												UpperCamelCase__					=       [files]
									UpperCamelCase__					=       [dl_manager.iter_files(UpperCamelCase__     ) for file in files]
									splits.append(datasets.SplitGenerator(name=UpperCamelCase__      ,						gen_kwargs={"files": files}     )     )
						return splits




			def 				snake_case__				(							self      ,						snake_case     ):

						'''simple docstring'''


						if self.config.features is not None:
									# adding missing columns
									for column_name in set(self.config.features     ) - set(pa_table.column_names     ):
												UpperCamelCase__					=       self.config.features.arrow_schema.field(UpperCamelCase__     ).type
												UpperCamelCase__					=       pa_table.append_column(UpperCamelCase__      ,						pa.array([None] * len(UpperCamelCase__     )      ,						type=UpperCamelCase__     )     )
									# more expensive cast to support nested structures with keys in a different order
									# allows str <-> int/float or str to Audio for example
									UpperCamelCase__					=       table_cast(UpperCamelCase__      ,						self.config.features.arrow_schema     )
						return pa_table







			def 				snake_case__				(							self      ,						snake_case     ):

						'''simple docstring'''


						for file_idx, file in enumerate(itertools.chain.from_iterable(UpperCamelCase__     )     ):
									# If the file is one json object and if we need to look at the list of items in one specific field
									if self.config.field is not None:
												with open(UpperCamelCase__      ,						encoding=self.config.encoding      ,						errors=self.config.encoding_errors     ) as f:
															UpperCamelCase__					=       json.load(UpperCamelCase__     )

												# We keep only the field we are interested in
												UpperCamelCase__					=       dataset[self.config.field]

												# We accept two format: a list of dicts or a dict of lists
												if isinstance(UpperCamelCase__      ,						(list, tuple)     ):
															UpperCamelCase__					=       set().union(*[row.keys() for row in dataset]     )
															UpperCamelCase__					=       {col: [row.get(UpperCamelCase__     ) for row in dataset] for col in keys}
												else:
															UpperCamelCase__					=       dataset
												UpperCamelCase__					=       pa.Table.from_pydict(UpperCamelCase__     )
												yield file_idx, self._cast_table(UpperCamelCase__     )

									# If the file has one json object per line
									else:
												with open(UpperCamelCase__      ,						"rb"     ) as f:
															UpperCamelCase__					=       0
															# Use block_size equal to the chunk size divided by 32 to leverage multithreading
															# Set a default minimum value of 16kB if the chunk size is really small
															UpperCamelCase__					=       max(self.config.chunksize // 32      ,						16 << 10     )
															UpperCamelCase__					=       (
															    self.config.encoding_errors if self.config.encoding_errors is not None else 'strict'
															)
															while True:
																		UpperCamelCase__					=       f.read(self.config.chunksize     )
																		if not batch:
																					break
																		# Finish current line
																		try:
																					batch += f.readline()
																		except (AttributeError, io.UnsupportedOperation):
																					batch += readline(UpperCamelCase__     )
																		# PyArrow only accepts utf-8 encoded bytes
																		if self.config.encoding != "utf-8":
																					UpperCamelCase__					=       batch.decode(self.config.encoding      ,						errors=UpperCamelCase__     ).encode("utf-8"     )
																		try:
																					while True:
																								try:
																											UpperCamelCase__					=       paj.read_json(
																											    io.BytesIO(UpperCamelCase__     )      ,						read_options=paj.ReadOptions(block_size=UpperCamelCase__     )     )
																											break
																								except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
																											if (
																											    isinstance(UpperCamelCase__      ,						pa.ArrowInvalid     )
																											    and "straddling" not in str(UpperCamelCase__     )
																											    or block_size > len(UpperCamelCase__     )
																											):
																														raise
																											else:
																														# Increase the block size in case it was too small.
																														# The block size will be reset for the next file.
																														logger.debug(
																														    F'''Batch of {len(UpperCamelCase__     )} bytes couldn\'t be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}.'''     )
																														block_size *= 2
																		except pa.ArrowInvalid as e:
																					try:
																								with open(
																								    UpperCamelCase__      ,						encoding=self.config.encoding      ,						errors=self.config.encoding_errors     ) as f:
																											UpperCamelCase__					=       json.load(UpperCamelCase__     )
																					except json.JSONDecodeError:
																								logger.error(F'''Failed to read file \'{file}\' with error {type(UpperCamelCase__     )}: {e}'''     )
																								raise e
																					# If possible, parse the file as a list of json objects and exit the loop
																					if isinstance(UpperCamelCase__      ,						UpperCamelCase__     ):  # list is the only sequence type supported in JSON
																								try:
																											UpperCamelCase__					=       set().union(*[row.keys() for row in dataset]     )
																											UpperCamelCase__					=       {col: [row.get(UpperCamelCase__     ) for row in dataset] for col in keys}
																											UpperCamelCase__					=       pa.Table.from_pydict(UpperCamelCase__     )
																								except (pa.ArrowInvalid, AttributeError) as e:
																											logger.error(F'''Failed to read file \'{file}\' with error {type(UpperCamelCase__     )}: {e}'''     )
																											raise ValueError(F'''Not able to read records in the JSON file at {file}.'''     ) from None
																								yield file_idx, self._cast_table(UpperCamelCase__     )
																								break
																					else:
																								logger.error(F'''Failed to read file \'{file}\' with error {type(UpperCamelCase__     )}: {e}'''     )
																								raise ValueError(
																								    F'''Not able to read records in the JSON file at {file}. '''
																								    F'''You should probably indicate the field of the JSON file containing your records. '''
																								    F'''This JSON file contain the following fields: {str(list(dataset.keys()     )     )}. '''
																								    F'''Select the correct one and provide it as `field=\'XXX\'` to the dataset loading method. '''     ) from None
                        # 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 (file_idx, batch_idx), self._cast_table(UpperCamelCase__     )
																		batch_idx += 1






from __future__ import annotations
def        UpperCamelCase_(				_A   :list[int]				,     _A   :int  )->		list[int]:
			UpperCamelCase__					=       0
			UpperCamelCase__					=       len(_A  ) - 1

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

			return []


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						print(f'''{two_pointer([2, 7, 1_1, 1_5], 9) = }''')


