code: import itertools
  from dataclasses import dataclass
  from typing import Optional
  
  import pyarrow as pa
  
  import datasets
  from datasets.table import table_cast
  
  
  UpperCAmelCase      :						List[str]    =		datasets.utils.logging.get_logger(__name__)
  
  
  
  
  
  
  
  @dataclass
  class 					__lowercase					(       datasets.BuilderConfig     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Tuple 					=		None
  
  
  
  
  
  
  
  class 					__lowercase					(       datasets.ArrowBasedBuilder     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				int 					=		ArrowConfig
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return datasets.DatasetInfo(features=self.config.features  )
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A  )     ->   Dict:
  
  
  
  
  
  
  
  					'''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(A		,			(str, list, tuple)  ):
  								lowerCamelCase								=     data_files
  								if isinstance(A		,			A  ):
  											lowerCamelCase								=     [files]
  								# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
  								lowerCamelCase								=     [dl_manager.iter_files(A  ) 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(A		,			A  ):
  											lowerCamelCase								=     [files]
  								# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
  								lowerCamelCase								=     [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:
  																	lowerCamelCase								=     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 				__A      (   self		,			A  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''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
  								lowerCamelCase								=     table_cast(A		,			self.info.features.arrow_schema  )
  					return pa_table
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A  )     ->   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  )  ):
  																	lowerCamelCase								=     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
  
  
style_context: 
  
  
  import abc
  import copy
  import dataclasses
  from dataclasses import dataclass
  from typing import ClassVar, Dict, Type, TypeVar
  
  from ..features import Features
  
  
  UpperCAmelCase      :						List[Any]    =		TypeVar("T", bound="TaskTemplate")
  
  
  
  
  
  
  
  @dataclass(frozen=a_     )
  class 					__lowercase					(       abc.ABC     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				str
  		UpperCamelCase    :				ClassVar[Features]
  		UpperCamelCase    :				ClassVar[Features]
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A  )     ->   T:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return copy.deepcopy(self  )
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   Features:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return Features(**self.input_schema		,			**self.label_schema  )
  
  
  
  
  
  
  
  		@property
  		@abc.abstractmethod
  		def 				__A      (   self  )     ->   Dict[str, str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					raise NotImplementedError
  
  
  
  
  
  
  
  		@classmethod
  		def 				__A      (   cls		,			A  )     ->   T:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     {f.name for f in dataclasses.fields(cls  )}
  					return cls(**{k: v for k, v in template_dict.items() if k in field_names}  )
  
  