'''simple docstring'''

import multiprocessing
import os
from typing import BinaryIO, Optional, Union

import fsspec

from .. import Dataset, Features, NamedSplit, config
from ..formatting import query_table
from ..packaged_modules.json.json import Json
from ..utils import logging
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader







class 				_lowercase     (				UpperCAmelCase__			):


 '''simple docstring'''






 def __init__(      self   :	Any      ,       SCREAMING_SNAKE_CASE__   :	NestedDataStructureLike[PathLike]      ,       SCREAMING_SNAKE_CASE__   :	Optional[NamedSplit] = None      ,       SCREAMING_SNAKE_CASE__   :	Optional[Features] = None      ,       SCREAMING_SNAKE_CASE__   :	str = None      ,       SCREAMING_SNAKE_CASE__   :	bool = False      ,       SCREAMING_SNAKE_CASE__   :	bool = False      ,       SCREAMING_SNAKE_CASE__   :	Optional[str] = None      ,       SCREAMING_SNAKE_CASE__   :	Optional[int] = None      ,       **SCREAMING_SNAKE_CASE__   :	int      ,       )  ->    List[str]:
  super().__init__(
      SCREAMING_SNAKE_CASE__      ,       split=SCREAMING_SNAKE_CASE__      ,       features=SCREAMING_SNAKE_CASE__      ,       cache_dir=SCREAMING_SNAKE_CASE__      ,       keep_in_memory=SCREAMING_SNAKE_CASE__      ,       streaming=SCREAMING_SNAKE_CASE__      ,       num_proc=SCREAMING_SNAKE_CASE__      ,       **SCREAMING_SNAKE_CASE__      ,       )
  __lowerCAmelCase											=						field
  __lowerCAmelCase											=						path_or_paths if isinstance(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							) else {self.split: path_or_paths}
  __lowerCAmelCase											=						Json(
      cache_dir=SCREAMING_SNAKE_CASE__      ,       data_files=SCREAMING_SNAKE_CASE__      ,       features=SCREAMING_SNAKE_CASE__      ,       field=SCREAMING_SNAKE_CASE__      ,       **SCREAMING_SNAKE_CASE__      ,       )





 def a					(      self   :	Optional[Any]							)  ->    Optional[int]:
  # Build iterable dataset
  if self.streaming:
   __lowerCAmelCase											=						self.builder.as_streaming_dataset(split=self.split							)
  # Build regular (map-style) dataset
  else:
   __lowerCAmelCase											=						None
   __lowerCAmelCase											=						None
   __lowerCAmelCase											=						None
   __lowerCAmelCase											=						None

   self.builder.download_and_prepare(
       download_config=SCREAMING_SNAKE_CASE__      ,       download_mode=SCREAMING_SNAKE_CASE__      ,       verification_mode=SCREAMING_SNAKE_CASE__      ,       base_path=SCREAMING_SNAKE_CASE__      ,       num_proc=self.num_proc      ,       )
   __lowerCAmelCase											=						self.builder.as_dataset(
       split=self.split      ,       verification_mode=SCREAMING_SNAKE_CASE__      ,       in_memory=self.keep_in_memory							)
  return dataset







class 				_lowercase     :


 '''simple docstring'''






 def __init__(      self   :	List[str]      ,       SCREAMING_SNAKE_CASE__   :	Dataset      ,       SCREAMING_SNAKE_CASE__   :	Union[PathLike, BinaryIO]      ,       SCREAMING_SNAKE_CASE__   :	Optional[int] = None      ,       SCREAMING_SNAKE_CASE__   :	Optional[int] = None      ,       **SCREAMING_SNAKE_CASE__   :	Optional[int]      ,       )  ->    Optional[Any]:
  if num_proc is not None and num_proc <= 0:
   raise ValueError(f"""num_proc {num_proc} must be an integer > 0."""							)

  __lowerCAmelCase											=						dataset
  __lowerCAmelCase											=						path_or_buf
  __lowerCAmelCase											=						batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
  __lowerCAmelCase											=						num_proc
  __lowerCAmelCase											=						"""utf-8"""
  __lowerCAmelCase											=						to_json_kwargs
 def a					(      self   :	Dict							)  ->    int:
  __lowerCAmelCase											=						self.to_json_kwargs.pop("""path_or_buf"""      ,       SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						self.to_json_kwargs.pop("""orient"""      ,       """records"""							)
  __lowerCAmelCase											=						self.to_json_kwargs.pop("""lines"""      ,       True if orient == """records""" else False							)
  __lowerCAmelCase											=						self.to_json_kwargs.pop("""index"""      ,       False if orient in ["""split""", """table"""] else True							)
  __lowerCAmelCase											=						self.to_json_kwargs.pop("""compression"""      ,       SCREAMING_SNAKE_CASE__							)

  if compression not in [None, "infer", "gzip", "bz2", "xz"]:
   raise NotImplementedError(f"""`datasets` currently does not support {compression} compression"""							)

  if isinstance(self.path_or_buf      ,       (str, bytes, os.PathLike)							):
   with fsspec.open(self.path_or_buf      ,       """wb"""      ,       compression=SCREAMING_SNAKE_CASE__							) as buffer:
    __lowerCAmelCase											=						self._write(file_obj=SCREAMING_SNAKE_CASE__      ,       orient=SCREAMING_SNAKE_CASE__      ,       lines=SCREAMING_SNAKE_CASE__      ,       index=SCREAMING_SNAKE_CASE__      ,       **self.to_json_kwargs							)
  else:
   if compression:
    raise NotImplementedError(
        f"""The compression parameter is not supported when writing to a buffer, but compression={compression}"""
        """ was passed. Please provide a local path instead."""							)
   __lowerCAmelCase											=						self._write(
       file_obj=self.path_or_buf      ,       orient=SCREAMING_SNAKE_CASE__      ,       lines=SCREAMING_SNAKE_CASE__      ,       index=SCREAMING_SNAKE_CASE__      ,       **self.to_json_kwargs							)
  return written
 def a					(      self   :	Any      ,       SCREAMING_SNAKE_CASE__   :	Tuple							)  ->    Optional[Any]:
  __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase											=						args

  __lowerCAmelCase											=						query_table(
      table=self.dataset.data      ,       key=slice(SCREAMING_SNAKE_CASE__      ,       offset + self.batch_size							)      ,       indices=self.dataset._indices      ,       )
  __lowerCAmelCase											=						batch.to_pandas().to_json(
      path_or_buf=SCREAMING_SNAKE_CASE__      ,       orient=SCREAMING_SNAKE_CASE__      ,       lines=SCREAMING_SNAKE_CASE__      ,       index=SCREAMING_SNAKE_CASE__      ,       **SCREAMING_SNAKE_CASE__							)
  if not json_str.endswith("""\n"""							):
   json_str += "\n"
  return json_str.encode(self.encoding							)





 def a					(      self   :	Optional[Any]      ,       SCREAMING_SNAKE_CASE__   :	BinaryIO      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	str      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       **SCREAMING_SNAKE_CASE__   :	Dict      ,       )  ->    int:
  __lowerCAmelCase											=						0

  if self.num_proc is None or self.num_proc == 1:
   for offset in logging.tqdm(
       range(0      ,       len(self.dataset							)      ,       self.batch_size							)      ,       unit="""ba"""      ,       disable=not logging.is_progress_bar_enabled()      ,       desc="""Creating json from Arrow format"""      ,       ):
    __lowerCAmelCase											=						self._batch_json((offset, orient, lines, index, to_json_kwargs)							)
    written += file_obj.write(SCREAMING_SNAKE_CASE__							)
  else:
   __lowerCAmelCase							,       __lowerCAmelCase											=						len(self.dataset							), self.batch_size
   with multiprocessing.Pool(self.num_proc							) as pool:
    for json_str in logging.tqdm(
        pool.imap(
            self._batch_json      ,       [(offset, orient, lines, index, to_json_kwargs) for offset in range(0      ,       SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)]      ,       )      ,       total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size      ,       unit="""ba"""      ,       disable=not logging.is_progress_bar_enabled()      ,       desc="""Creating json from Arrow format"""      ,       ):
     written += file_obj.write(SCREAMING_SNAKE_CASE__							)

  return written







'''simple docstring'''

def      UpperCamelCase_						(					snake_case_       :       Union[str, Any]=2_81_23      )					->     str:






 '''simple docstring'''

 __lowerCAmelCase											=						[1] * (limit + 1)

 for i in range(2						,		int(limit**0.5      ) + 1      ):
  sum_divs[i * i] += i
  for k in range(i + 1						,		limit // i + 1      ):
   sum_divs[k * i] += k + i

 __lowerCAmelCase											=						set()
 __lowerCAmelCase											=						0

 for n in range(1						,		limit + 1      ):
  if sum_divs[n] > n:
   abundants.add(snake_case_      )

  if not any((n - a in abundants) for a in abundants      ):
   res += n

 return res


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






