



import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


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






@dataclass
class  lowerCamelCase_   (    datasets.BuilderConfig					):
  """simple docstring"""




  a_							 =None






class  lowerCamelCase_   (    datasets.ArrowBasedBuilder					):
  """simple docstring"""




  a_							 =ArrowConfig




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




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




  def 						_lowercase					(			self				:     Dict      ,     _a				:     pa.Table       ) -> pa.Table:
    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	:	Any   	=			table_cast(_snake_case      ,     self.info.features.arrow_schema       )
    return pa_table




  def 						_lowercase					(			self				:     Optional[Any]      ,     _a				:     List[str]       ) -> Dict:
    for file_idx, file in enumerate(itertools.chain.from_iterable(_snake_case       )       ):
      with open(_snake_case      ,     'rb'       ) as f:
        try:
          for batch_idx, record_batch in enumerate(pa.ipc.open_stream(_snake_case       )       ):
            __lowerCamelCase	:	str   	=			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(_snake_case       )
        except ValueError as e:
          logger.error(f'Failed to read file \'{file}\' with error {type(_snake_case       )}: {e}'       )
          raise











'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_UpperCamelCase							    =						{
    'configuration_imagegpt': ['IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ImageGPTConfig', 'ImageGPTOnnxConfig']
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase							    =						['ImageGPTFeatureExtractor']
   _UpperCamelCase							    =						['ImageGPTImageProcessor']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase							    =						[
       'IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'ImageGPTForCausalImageModeling',
       'ImageGPTForImageClassification',
       'ImageGPTModel',
       'ImageGPTPreTrainedModel',
       'load_tf_weights_in_imagegpt',
   ]


if TYPE_CHECKING:
   from .configuration_imagegpt import IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ImageGPTConfig, ImageGPTOnnxConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_imagegpt import ImageGPTFeatureExtractor
      from .image_processing_imagegpt import ImageGPTImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_imagegpt import (
          IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          ImageGPTForCausalImageModeling,
          ImageGPTForImageClassification,
          ImageGPTModel,
          ImageGPTPreTrainedModel,
          load_tf_weights_in_imagegpt,
      )

else:
   import sys

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






