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


lowerCAmelCase_:					List[str]     =					datasets.utils.logging.get_logger(__name__)






@dataclass
class    a__    (   datasets.BuilderConfig	):
   snake_case_							=      None
   snake_case_							=      "utf-8"
   snake_case_							=      None
   snake_case_							=      None
   snake_case_							=      True  # deprecated
   snake_case_							=      None  # deprecated
   snake_case_							=      10 << 20  # 10MB
   snake_case_							=      None






class    a__    (   datasets.ArrowBasedBuilder	):
   snake_case_							=      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"  )
             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 	snake_case__	(     self,				_UpperCAmelCase  ):
        '''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(_UpperCAmelCase,				(str, list, tuple)  ):
             lowercase__				 =							data_files
             if isinstance(_UpperCAmelCase,				_UpperCAmelCase  ):
                  lowercase__				 =							[files]
             lowercase__				 =							[dl_manager.iter_files(_UpperCAmelCase  ) 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(_UpperCAmelCase,				_UpperCAmelCase  ):
                  lowercase__				 =							[files]
             lowercase__				 =							[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,				_UpperCAmelCase  ):
        '''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(_UpperCAmelCase  ).type
                  lowercase__				 =							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
             lowercase__				 =							table_cast(_UpperCAmelCase,				self.config.features.arrow_schema  )
        return pa_table


   def 	snake_case__	(     self,				_UpperCAmelCase  ):
        '''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:
                       lowercase__				 =							json.load(_UpperCAmelCase  )

                  # 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(_UpperCAmelCase,				(list, tuple)  ):
                       lowercase__				 =							set().union(*[row.keys() for row in dataset]  )
                       lowercase__				 =							{col: [row.get(_UpperCAmelCase  ) for row in dataset] for col in keys}
                  else:
                       lowercase__				 =							dataset
                  lowercase__				 =							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:
                       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(_UpperCAmelCase  )
                            # PyArrow only accepts utf-8 encoded bytes
                            if self.config.encoding != "utf-8":
                                 lowercase__				 =							batch.decode(self.config.encoding,				errors=_UpperCAmelCase  ).encode("utf-8"  )
                            try:
                                 while True:
                                      try:
                                           lowercase__				 =							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:
                                           lowercase__				 =							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:
                                           lowercase__				 =							set().union(*[row.keys() for row in dataset]  )
                                           lowercase__				 =							{col: [row.get(_UpperCAmelCase  ) for row in dataset] for col in keys}
                                           lowercase__				 =							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





"""simple docstring"""


import itertools
import math







def 					__a   (		A      ):






     '''simple docstring'''



     if 1 < number < 4:
          # 2 and 3 are primes
          return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
          # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
          return False

     # All primes number are in format of 6k +/- 1
     for i in range(5    ,				int(math.sqrt(A      ) + 1      )    ,				6      ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True







def 					__a   (		):






     '''simple docstring'''



     lowercase__				 =							2
     while True:
          if is_prime(A      ):
               yield num
          num += 1







def 					__a   (		A = 1_00_01      ):






     '''simple docstring'''



     return next(itertools.islice(prime_generator()    ,				nth - 1    ,				A      )      )


if __name__ == "__main__":
 print(F'{solution() = }')




