




import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


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


@dataclass
class  lowerCamelCase     (		datasets.BuilderConfig    ):






			'''simple docstring'''





			UpperCamelCase__										=None






class  lowerCamelCase     (		datasets.ArrowBasedBuilder    ):






			'''simple docstring'''





			UpperCamelCase__										=ArrowConfig

			def 				UpperCAmelCase__							(			self      : str	)    -> Union[str, Any]:
								return datasets.DatasetInfo(features=self.config.features	)

			def 				UpperCAmelCase__							(			self      : List[Any]							,    lowerCamelCase_      : Optional[Any]	)    -> Optional[int]:



								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}'''	)
								__magic_name__				:						str     				=				dl_manager.download_and_extract(self.config.data_files	)
								if isinstance(__lowerCamelCase							,    (str, list, tuple)	):
													__magic_name__				:						List[str]     				=				data_files
													if isinstance(__lowerCamelCase							,    __lowerCamelCase	):
																		__magic_name__				:						Tuple     				=				[files]
													# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
													__magic_name__				:						Dict     				=				[dl_manager.iter_files(__lowerCamelCase	) for file in files]
													return [datasets.SplitGenerator(name=datasets.Split.TRAIN							,    gen_kwargs={'''files''': files}	)]
								__magic_name__				:						int     				=				[]
								for split_name, files in data_files.items():
													if isinstance(__lowerCamelCase							,    __lowerCamelCase	):
																		__magic_name__				:						int     				=				[files]
													# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
													__magic_name__				:						Optional[Any]     				=				[dl_manager.iter_files(__lowerCamelCase	) for file in files]
													# Infer features is they are stoed in the arrow schema
													if self.info.features is None:
																		for file in itertools.chain.from_iterable(__lowerCamelCase	):
																							with open(__lowerCamelCase							,    '''rb'''	) as f:
																												__magic_name__				:						Optional[Any]     				=				datasets.Features.from_arrow_schema(pa.ipc.open_stream(__lowerCamelCase	).schema	)
																							break
													splits.append(datasets.SplitGenerator(name=__lowerCamelCase							,    gen_kwargs={'''files''': files}	)	)
								return splits

			def 				UpperCAmelCase__							(			self      : List[str]							,    lowerCamelCase_      : pa.Table	)    -> Dict:



								if self.info.features is not None:
													# more expensive cast to support nested features with keys in a different order
													# allows str <-> int/float or str to Audio for example
													__magic_name__				:						Optional[Any]     				=				table_cast(__lowerCamelCase							,    self.info.features.arrow_schema	)
								return pa_table


			def 				UpperCAmelCase__							(			self      : Any							,    lowerCamelCase_      : Optional[int]	)    -> Union[str, Any]:



								for file_idx, file in enumerate(itertools.chain.from_iterable(__lowerCamelCase	)	):
													with open(__lowerCamelCase							,    '''rb'''	) as f:
																		try:
																							for batch_idx, record_batch in enumerate(pa.ipc.open_stream(__lowerCamelCase	)	):
																												__magic_name__				:						List[Any]     				=				pa.Table.from_batches([record_batch]	)
																												# 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 F'''{file_idx}_{batch_idx}''', self._cast_table(__lowerCamelCase	)
																		except ValueError as e:
																							logger.error(F'''Failed to read file \'{file}\' with error {type(__lowerCamelCase	)}: {e}'''	)
																							raise







def  lowercase_						(						_A     :       int		):

      """simple docstring"""




      if not isinstance(_A       ,   _A		):
            raise ValueError("double_factorial() only accepts integral values"		)
      if num < 0:
            raise ValueError("double_factorial() not defined for negative values"		)
      lowerCamelCase__						:							Union[str, Any]       =    1
      for i in range(_A       ,   0       ,   -2		):
            value *= i
      return value


if __name__ == "__main__":
    import doctest

    doctest.testmod()


