

'''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 					_snake_case		(__SCREAMING_SNAKE_CASE):






			def __init__(  self			,_snake_case			,_snake_case = None			,_snake_case = None			,_snake_case = None			,_snake_case = False			,_snake_case = False			,_snake_case = None			,_snake_case = None			,**_snake_case			,):
				super().__init__(
				    _snake_case			,split=_snake_case			,features=_snake_case			,cache_dir=_snake_case			,keep_in_memory=_snake_case			,streaming=_snake_case			,num_proc=_snake_case			,**_snake_case			,)
				UpperCAmelCase_     :      Tuple						=  field
				UpperCAmelCase_     :      List[Any]						=  path_or_paths if isinstance(_snake_case			,_snake_case     ) else {self.split: path_or_paths}
				UpperCAmelCase_     :      Optional[int]						=  Json(
				    cache_dir=_snake_case			,data_files=_snake_case			,features=_snake_case			,field=_snake_case			,**_snake_case			,)






			def 		UpperCamelCase__							(  self     ):
				# Build iterable dataset
				if self.streaming:
					UpperCAmelCase_     :      List[str]						=  self.builder.as_streaming_dataset(split=self.split     )
				# Build regular (map-style) dataset
				else:
					UpperCAmelCase_     :      Union[str, Any]						=  None
					UpperCAmelCase_     :      int						=  None
					UpperCAmelCase_     :      List[Any]						=  None
					UpperCAmelCase_     :      int						=  None

					self.builder.download_and_prepare(
					    download_config=_snake_case			,download_mode=_snake_case			,verification_mode=_snake_case			,base_path=_snake_case			,num_proc=self.num_proc			,)
					UpperCAmelCase_     :      Dict						=  self.builder.as_dataset(
					    split=self.split			,verification_mode=_snake_case			,in_memory=self.keep_in_memory     )
				return dataset




class 					_snake_case		:






			def __init__(  self			,_snake_case			,_snake_case			,_snake_case = None			,_snake_case = None			,**_snake_case			,):
				if num_proc is not None and num_proc <= 0:
					raise ValueError(f'''num_proc {num_proc} must be an integer > 0.'''     )

				UpperCAmelCase_     :      int						=  dataset
				UpperCAmelCase_     :      Union[str, Any]						=  path_or_buf
				UpperCAmelCase_     :      str						=  batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
				UpperCAmelCase_     :      Dict						=  num_proc
				UpperCAmelCase_     :      Optional[Any]						=  "utf-8"
				UpperCAmelCase_     :      Optional[int]						=  to_json_kwargs






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Dict						=  self.to_json_kwargs.pop("path_or_buf"			,_snake_case     )
				UpperCAmelCase_     :      Tuple						=  self.to_json_kwargs.pop("orient"			,"records"     )
				UpperCAmelCase_     :      Any						=  self.to_json_kwargs.pop("lines"			,True if orient == "records" else False     )
				UpperCAmelCase_     :      Optional[int]						=  self.to_json_kwargs.pop("index"			,False if orient in ["split", "table"] else True     )
				UpperCAmelCase_     :      int						=  self.to_json_kwargs.pop("compression"			,_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=_snake_case     ) as buffer:
						UpperCAmelCase_     :      List[str]						=  self._write(file_obj=_snake_case			,orient=_snake_case			,lines=_snake_case			,index=_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."     )
					UpperCAmelCase_     :      Union[str, Any]						=  self._write(
					    file_obj=self.path_or_buf			,orient=_snake_case			,lines=_snake_case			,index=_snake_case			,**self.to_json_kwargs     )
				return written






			def 		UpperCamelCase__							(  self			,_snake_case     ):
				UpperCAmelCase_					,					UpperCAmelCase_					,					UpperCAmelCase_					,					UpperCAmelCase_					,					UpperCAmelCase_     :      Optional[int]						=  args

				UpperCAmelCase_     :      List[str]						=  query_table(
				    table=self.dataset.data			,key=slice(_snake_case			,offset + self.batch_size     )			,indices=self.dataset._indices			,)
				UpperCAmelCase_     :      Optional[Any]						=  batch.to_pandas().to_json(
				    path_or_buf=_snake_case			,orient=_snake_case			,lines=_snake_case			,index=_snake_case			,**_snake_case     )
				if not json_str.endswith("\n"     ):
					json_str += "\n"
				return json_str.encode(self.encoding     )






			def 		UpperCamelCase__							(  self			,_snake_case			,_snake_case			,_snake_case			,_snake_case			,**_snake_case			,):
				UpperCAmelCase_     :      Optional[Any]						=  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"			,):
						UpperCAmelCase_     :      Any						=  self._batch_json((offset, orient, lines, index, to_json_kwargs)     )
						written += file_obj.write(_snake_case     )
				else:
					UpperCAmelCase_					,					UpperCAmelCase_     :      int						=  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			,_snake_case			,_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(_snake_case     )

				return written






def 							a		(				snake_case__:   int   ):


				'''simple docstring'''
				if not isinstance(snake_case__		,  snake_case__   ):
								raise ValueError('''Input must be an integer'''   )
				if input_num <= 0:
								raise ValueError('''Input must be positive'''   )
				return sum(
				    divisor for divisor in range(1		,  input_num // 2 + 1   ) if input_num % divisor == 0   )


if __name__ == "__main__":
						import doctest

						doctest.testmod()




