





'''simple docstring'''



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


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






@dataclass
class 							__lowercase    ( datasets.BuilderConfig  ):







	'''simple docstring'''

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






class 							__lowercase    ( datasets.ArrowBasedBuilder  ):







	'''simple docstring'''

	a      :			List[Any]     =    JsonConfig


	def   _UpperCAmelCase       (self	)							->							Union[str, Any]:







				'''simple docstring'''





				if self.config.block_size is not None:
							logger.warning('''The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead'''	)
							__lowercase			  =							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   _UpperCAmelCase       (self       ,_lowerCamelCase	)							->							List[str]:







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


	def   _UpperCAmelCase       (self       ,_lowerCamelCase	)							->							pa.Table:







				'''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	):
										__lowercase			  =							self.config.features.arrow_schema.field(_lowerCamelCase	).type
										__lowercase			  =							pa_table.append_column(_lowerCamelCase       ,pa.array([None] * len(_lowerCamelCase	)       ,type=_lowerCamelCase	)	)
							# more expensive cast to support nested structures with keys in a different order
							# allows str <-> int/float or str to Audio for example
							__lowercase			  =							table_cast(_lowerCamelCase       ,self.config.features.arrow_schema	)
				return pa_table


	def   _UpperCAmelCase       (self       ,_lowerCamelCase	)							->							Dict:







				'''simple docstring'''





				for file_idx, file in enumerate(itertools.chain.from_iterable(_lowerCamelCase	)	):
							# 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(_lowerCamelCase       ,encoding=self.config.encoding       ,errors=self.config.encoding_errors	) as f:
													__lowercase			  =							json.load(_lowerCamelCase	)

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

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

							# If the file has one json object per line
							else:
										with open(_lowerCamelCase       ,'''rb'''	) as f:
													__lowercase			  =							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
													__lowercase			  =							max(self.config.chunksize // 32       ,16 << 10	)
													__lowercase			  =							(
													    self.config.encoding_errors if self.config.encoding_errors is not None else '''strict'''
													)
													while True:
																__lowercase			  =							f.read(self.config.chunksize	)
																if not batch:
																			break
																# Finish current line
																try:
																			batch += f.readline()
																except (AttributeError, io.UnsupportedOperation):
																			batch += readline(_lowerCamelCase	)
																# PyArrow only accepts utf-8 encoded bytes
																if self.config.encoding != "utf-8":
																			__lowercase			  =							batch.decode(self.config.encoding       ,errors=_lowerCamelCase	).encode('''utf-8'''	)
																try:
																			while True:
																						try:
																									__lowercase			  =							paj.read_json(
																									    io.BytesIO(_lowerCamelCase	)       ,read_options=paj.ReadOptions(block_size=_lowerCamelCase	)	)
																									break
																						except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
																									if (
																									    isinstance(_lowerCamelCase       ,pa.ArrowInvalid	)
																									    and "straddling" not in str(_lowerCamelCase	)
																									    or block_size > len(_lowerCamelCase	)
																									):
																												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(_lowerCamelCase	)} 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(
																						    _lowerCamelCase       ,encoding=self.config.encoding       ,errors=self.config.encoding_errors	) as f:
																									__lowercase			  =							json.load(_lowerCamelCase	)
																			except json.JSONDecodeError:
																						logger.error(f"Failed to read file '{file}' with error {type(_lowerCamelCase	)}: {e}"	)
																						raise e
																			# If possible, parse the file as a list of json objects and exit the loop
																			if isinstance(_lowerCamelCase       ,_lowerCamelCase	):  # list is the only sequence type supported in JSON
																						try:
																									__lowercase			  =							set().union(*[row.keys() for row in dataset]	)
																									__lowercase			  =							{col: [row.get(_lowerCamelCase	) for row in dataset] for col in keys}
																									__lowercase			  =							pa.Table.from_pydict(_lowerCamelCase	)
																						except (pa.ArrowInvalid, AttributeError) as e:
																									logger.error(f"Failed to read file '{file}' with error {type(_lowerCamelCase	)}: {e}"	)
																									raise ValueError(f"Not able to read records in the JSON file at {file}."	) from None
																						yield file_idx, self._cast_table(_lowerCamelCase	)
																						break
																			else:
																						logger.error(f"Failed to read file '{file}' with error {type(_lowerCamelCase	)}: {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(_lowerCamelCase	)
																batch_idx += 1












'''simple docstring'''



def 				_lowerCAmelCase  (			lowerCamelCase_     :					Union[str, Any]			):
			__lowercase			  =							1
			__lowercase			  =							2
			while i * i <= n:
						__lowercase			  =							0
						while n % i == 0:
									n //= i
									multiplicity += 1
						n_divisors *= multiplicity + 1
						i += 1
			if n > 1:
						n_divisors *= 2
			return n_divisors




def 				_lowerCAmelCase  (			):
			__lowercase			  =							1
			__lowercase			  =							1

			while True:
						i += 1
						t_num += i

						if count_divisors(lowerCamelCase_			) > 5_0_0:
									break

			return t_num


if __name__ == "__main__":
	print(solution())





