'''simple docstring'''




import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


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






@dataclass
class     a__( datasets.BuilderConfig     ):


			'''simple docstring'''






			UpperCAmelCase_      :					Optional[datasets.Features]								=	None







class     a__( datasets.ArrowBasedBuilder     ):


			'''simple docstring'''






			UpperCAmelCase_      :					Optional[Any]								=	ArrowConfig



			def 							a_	(       self):




					"""simple docstring"""


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



			def 							a_	(       self	,   __lowerCAmelCase):




					"""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(__lowerCAmelCase	,   (str, list, tuple)):
							lowerCAmelCase        =  data_files
							if isinstance(__lowerCAmelCase	,   __lowerCAmelCase):
									lowerCAmelCase        =  [files]
							# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
							lowerCAmelCase        =  [dl_manager.iter_files(__lowerCAmelCase) 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(__lowerCAmelCase	,   __lowerCAmelCase):
									lowerCAmelCase        =  [files]
							# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
							lowerCAmelCase        =  [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:
													lowerCAmelCase        =  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 							a_	(       self	,   __lowerCAmelCase):




					"""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(__lowerCAmelCase	,   self.info.features.arrow_schema)
					return pa_table







			def 							a_	(       self	,   __lowerCAmelCase):




					"""simple docstring"""


					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)):
													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(__lowerCAmelCase)
									except ValueError as e:
											logger.error(f"Failed to read file '{file}' with error {type(__lowerCAmelCase)}: {e}")
											raise





'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowercase				   =  {
    '''configuration_bart''': ['''BART_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BartConfig''', '''BartOnnxConfig'''],
    '''tokenization_bart''': ['''BartTokenizer'''],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  ['''BartTokenizerFast''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  [
						    '''BART_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''BartForCausalLM''',
						    '''BartForConditionalGeneration''',
						    '''BartForQuestionAnswering''',
						    '''BartForSequenceClassification''',
						    '''BartModel''',
						    '''BartPretrainedModel''',
						    '''PretrainedBartModel''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  [
						    '''TFBartForConditionalGeneration''',
						    '''TFBartForSequenceClassification''',
						    '''TFBartModel''',
						    '''TFBartPretrainedModel''',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase				   =  [
						    '''FlaxBartDecoderPreTrainedModel''',
						    '''FlaxBartForCausalLM''',
						    '''FlaxBartForConditionalGeneration''',
						    '''FlaxBartForQuestionAnswering''',
						    '''FlaxBartForSequenceClassification''',
						    '''FlaxBartModel''',
						    '''FlaxBartPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_bart import BART_PRETRAINED_CONFIG_ARCHIVE_MAP, BartConfig, BartOnnxConfig
						from .tokenization_bart import BartTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_bart_fast import BartTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_bart import (
												    BART_PRETRAINED_MODEL_ARCHIVE_LIST,
												    BartForCausalLM,
												    BartForConditionalGeneration,
												    BartForQuestionAnswering,
												    BartForSequenceClassification,
												    BartModel,
												    BartPretrainedModel,
												    PretrainedBartModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_bart import (
												    TFBartForConditionalGeneration,
												    TFBartForSequenceClassification,
												    TFBartModel,
												    TFBartPretrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_bart import (
												    FlaxBartDecoderPreTrainedModel,
												    FlaxBartForCausalLM,
												    FlaxBartForConditionalGeneration,
												    FlaxBartForQuestionAnswering,
												    FlaxBartForSequenceClassification,
												    FlaxBartModel,
												    FlaxBartPreTrainedModel,
												)

else:
						import sys

						__lowercase				   =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




