





import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


_lowerCamelCase							=     datasets.utils.logging.get_logger(__name__)




@dataclass
class 					UpperCamelCase_    (       datasets.BuilderConfig      ):
							lowerCamelCase_          =   None




class 					UpperCamelCase_    (       datasets.ArrowBasedBuilder      ):
							lowerCamelCase_          =   ArrowConfig


							def        _snake_case					(							self      :Optional[Any]						)				->				Union[str, Any]:



									"""simple docstring"""



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


							def        _snake_case					(							self      :Dict							,			__A      :Any						)				->				Optional[Any]:



									"""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}'''						)
									SCREAMING_SNAKE_CASE__								= dl_manager.download_and_extract(self.config.data_files						)
									if isinstance(__A							,			(str, list, tuple)						):
											SCREAMING_SNAKE_CASE__								= data_files
											if isinstance(__A							,			__A						):
													SCREAMING_SNAKE_CASE__								= [files]
											# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
											SCREAMING_SNAKE_CASE__								= [dl_manager.iter_files(__A						) for file in files]
											return [datasets.SplitGenerator(name=datasets.Split.TRAIN							,			gen_kwargs={"""files""": files}						)]
									SCREAMING_SNAKE_CASE__								= []
									for split_name, files in data_files.items():
											if isinstance(__A							,			__A						):
													SCREAMING_SNAKE_CASE__								= [files]
											# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
											SCREAMING_SNAKE_CASE__								= [dl_manager.iter_files(__A						) 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(__A						):
															with open(__A							,			"""rb"""						) as f:
																	SCREAMING_SNAKE_CASE__								= datasets.Features.from_arrow_schema(pa.ipc.open_stream(__A						).schema						)
															break
											splits.append(datasets.SplitGenerator(name=__A							,			gen_kwargs={"""files""": files}						)						)
									return splits


							def        _snake_case					(							self      :List[Any]							,			__A      :pa.Table						)				->				pa.Table:



									"""simple docstring"""



									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
											SCREAMING_SNAKE_CASE__								= table_cast(__A							,			self.info.features.arrow_schema						)
									return pa_table


							def        _snake_case					(							self      :Union[str, Any]							,			__A      :List[Any]						)				->				List[Any]:



									"""simple docstring"""



									for file_idx, file in enumerate(itertools.chain.from_iterable(__A						)						):
											with open(__A							,			"""rb"""						) as f:
													try:
															for batch_idx, record_batch in enumerate(pa.ipc.open_stream(__A						)						):
																	SCREAMING_SNAKE_CASE__								= 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(__A						)
													except ValueError as e:
															logger.error(f'''Failed to read file \'{file}\' with error {type(__A						)}: {e}'''						)
															raise






from __future__ import annotations






def 			SCREAMING_SNAKE_CASE__							(    UpperCamelCase__:							list[int | float]      ):
		if len(UpperCamelCase__      ) == 0:
				raise ValueError("""find_min() arg is an empty sequence"""      )
		SCREAMING_SNAKE_CASE__								= nums[0]
		for num in nums:
				SCREAMING_SNAKE_CASE__								= min(UpperCamelCase__   ,				UpperCamelCase__      )
		return min_num


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)