






"""simple docstring"""



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

import pyarrow as pa

import datasets
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


_snake_case       :      Optional[Any]       =					datasets.utils.logging.get_logger(__name__)




@dataclass
class        __lowercase(       datasets.BuilderConfig  ):
						lowerCAmelCase_		:							Optional[datasets.Features]=       None
						lowerCAmelCase_		:							str=       "utf-8"
						lowerCAmelCase_		:							Optional[str]=       None
						lowerCAmelCase_		:							int=       10 << 20  # 10MB
						lowerCAmelCase_		:							bool=       False
						lowerCAmelCase_		:							str=       "line"




class        __lowercase(       datasets.ArrowBasedBuilder  ):
						lowerCAmelCase_		:							Optional[Any]=       TextConfig






						def 		lowerCAmelCase   (					self)			->  List[Any]:




											"""simple docstring"""





											return datasets.DatasetInfo(features=self.config.features)






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






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  pa.Table:




											"""simple docstring"""





											if self.config.features is not None:
																lowerCamelCase__				=self.config.features.arrow_schema
																if all(not require_storage_cast(_SCREAMING_SNAKE_CASE) for feature in self.config.features.values()):
																					# cheaper cast
																					lowerCamelCase__				=pa_table.cast(_SCREAMING_SNAKE_CASE)
																else:
																					# more expensive cast; allows str <-> int/float or str to Audio for example
																					lowerCamelCase__				=table_cast(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
																return pa_table
											else:
																return pa_table.cast(pa.schema({'text': pa.string()}))






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  int:




											"""simple docstring"""





											lowerCamelCase__				=list(self.config.features) if self.config.features is not None else ['text']
											for file_idx, file in enumerate(itertools.chain.from_iterable(_SCREAMING_SNAKE_CASE)):
																# open in text mode, by default translates universal newlines ("\n", "\r\n" and "\r") into "\n"
																with open(_SCREAMING_SNAKE_CASE    ,						encoding=self.config.encoding    ,						errors=self.config.errors) as f:
																					if self.config.sample_by == "line":
																										lowerCamelCase__				=0
																										while True:
																															lowerCamelCase__				=f.read(self.config.chunksize)
																															if not batch:
																																				break
																															batch += f.readline()  # finish current line
																															# StringIO.readlines, by default splits only on "\n" (and keeps line breaks)
																															lowerCamelCase__				=StringIO(_SCREAMING_SNAKE_CASE).readlines()
																															if not self.config.keep_linebreaks:
																																				lowerCamelCase__				=[line.rstrip('\n') for line in batch]
																															lowerCamelCase__				=pa.Table.from_arrays([pa.array(_SCREAMING_SNAKE_CASE)]    ,						names=_SCREAMING_SNAKE_CASE)
																															# 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(_SCREAMING_SNAKE_CASE)
																															batch_idx += 1
																					elif self.config.sample_by == "paragraph":
																										lowerCamelCase__				=0
																										lowerCamelCase__				=''
																										while True:
																															lowerCamelCase__				=f.read(self.config.chunksize)
																															if not new_batch:
																																				break
																															batch += new_batch
																															batch += f.readline()  # finish current line
																															lowerCamelCase__				=batch.split('\n\n')
																															lowerCamelCase__				=pa.Table.from_arrays(
																															    [pa.array([example for example in batch[:-1] if example])]    ,						names=_SCREAMING_SNAKE_CASE)
																															# 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(_SCREAMING_SNAKE_CASE)
																															batch_idx += 1
																															lowerCamelCase__				=batch[-1]
																										if batch:
																															lowerCamelCase__				=pa.Table.from_arrays([pa.array([batch])]    ,						names=_SCREAMING_SNAKE_CASE)
																															yield (file_idx, batch_idx), self._cast_table(_SCREAMING_SNAKE_CASE)
																					elif self.config.sample_by == "document":
																										lowerCamelCase__				=f.read()
																										lowerCamelCase__				=pa.Table.from_arrays([pa.array([text])]    ,						names=_SCREAMING_SNAKE_CASE)
																										yield file_idx, self._cast_table(_SCREAMING_SNAKE_CASE)







"""simple docstring"""



from doctest import testmod
from math import sqrt




def 						lowerCamelCase_				(  __A  :		int			):
					lowerCamelCase__				=[]
					if num < 1:
										return facs
					facs.append(1			)
					if num == 1:
										return facs
					facs.append(__A			)
					for i in range(2			,	int(sqrt(__A			)			) + 1			):
										if num % i == 0:  # If i is a factor of num
															facs.append(__A			)
															lowerCamelCase__				=num // i  # num//i is the other factor of num
															if d != i:  # If d and i are distinct
																				facs.append(__A			)  # we have found another factor
					facs.sort()
					return facs


if __name__ == "__main__":
						testmod(name="factors_of_a_number", verbose=True)