import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


__lowerCamelCase :     Tuple          =  datasets.utils.logging.get_logger(__name__)






@dataclass
class 		a__						( datasets.BuilderConfig ):
					A     	=							None







class 		a__						( datasets.ArrowBasedBuilder ):
					A     	=							ArrowConfig

					def     __UpperCamelCase       (   self				:	List[str]   ):







							"""simple docstring"""






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

					def     __UpperCamelCase       (   self				:	Any,_A				:	int   ):







							"""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_  :		str    				=   dl_manager.download_and_extract(self.config.data_files   )
							if isinstance(_A,(str, list, tuple)   ):
									SCREAMING_SNAKE_CASE_  :		Dict    				=   data_files
									if isinstance(_A,_A   ):
											SCREAMING_SNAKE_CASE_  :		Dict    				=   [files]
									# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
									SCREAMING_SNAKE_CASE_  :		int    				=   [dl_manager.iter_files(_A   ) for file in files]
									return [datasets.SplitGenerator(name=datasets.Split.TRAIN,gen_kwargs={"files": files}   )]
							SCREAMING_SNAKE_CASE_  :		List[str]    				=   []
							for split_name, files in data_files.items():
									if isinstance(_A,_A   ):
											SCREAMING_SNAKE_CASE_  :		int    				=   [files]
									# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
									SCREAMING_SNAKE_CASE_  :		Any    				=   [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_  :		str    				=   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     __UpperCamelCase       (   self				:	Union[str, Any],_A				:	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_  :		Optional[int]    				=   table_cast(_A,self.info.features.arrow_schema   )
							return pa_table






					def     __UpperCamelCase       (   self				:	int,_A				:	List[str]   ):







							"""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_  :		Union[str, 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(_A   )
											except ValueError as e:
													logger.error(F'Failed to read file \'{file}\' with error {type(_A   )}: {e}'   )
													raise

from ..utils import DummyObject, requires_backends






class 		a__						( metaclass=A__ ):
					A     	=							['tensorflow_text']

					def __init__(   self				:	List[str],*_A				:	Optional[Any],**_A				:	int   ):







							"""simple docstring"""






							requires_backends(self,["tensorflow_text"]   )
