code: 
  
  
  import multiprocessing
  import os
  from typing import BinaryIO, Optional, Union
  
  from .. import Dataset, Features, NamedSplit, config
  from ..formatting import query_table
  from ..packaged_modules.csv.csv import Csv
  from ..utils import logging
  from ..utils.typing import NestedDataStructureLike, PathLike
  from .abc import AbstractDatasetReader
  
  
  
  
  
  class    A					(     A_				):
  
  
  							def __init__(self   ,       lowerCAmelCase   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = False   ,       lowerCAmelCase = False   ,       lowerCAmelCase = None   ,       **lowerCAmelCase   ,       ):
  													super().__init__(
  													    lowerCAmelCase   ,       split=lowerCAmelCase   ,       features=lowerCAmelCase   ,       cache_dir=lowerCAmelCase   ,       keep_in_memory=lowerCAmelCase   ,       streaming=lowerCAmelCase   ,       num_proc=lowerCAmelCase   ,       **lowerCAmelCase   ,       )
  													__lowercase=    path_or_paths if isinstance(lowerCAmelCase   ,       lowerCAmelCase      ) else {self.split: path_or_paths}
  													__lowercase=    Csv(
  													    cache_dir=lowerCAmelCase   ,       data_files=lowerCAmelCase   ,       features=lowerCAmelCase   ,       **lowerCAmelCase   ,       )
  
  
  
  
  
  
  
  							def     _A (self      ):
  													# Build iterable dataset
  													if self.streaming:
  																			__lowercase=    self.builder.as_streaming_dataset(split=self.split      )
  													# Build regular (map-style) dataset
  													else:
  																			__lowercase=    None
  																			__lowercase=    None
  																			__lowercase=    None
  																			__lowercase=    None
  
  																			self.builder.download_and_prepare(
  																			    download_config=lowerCAmelCase   ,       download_mode=lowerCAmelCase   ,       verification_mode=lowerCAmelCase   ,       base_path=lowerCAmelCase   ,       num_proc=self.num_proc   ,       )
  																			__lowercase=    self.builder.as_dataset(
  																			    split=self.split   ,       verification_mode=lowerCAmelCase   ,       in_memory=self.keep_in_memory      )
  													return dataset
  
  
  
  
  
  class    A					:
  
  
  							def __init__(self   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       **lowerCAmelCase   ,       ):
  													if num_proc is not None and num_proc <= 0:
  																			raise ValueError(f'num_proc {num_proc} must be an integer > 0.'      )
  
  													__lowercase=    dataset
  													__lowercase=    path_or_buf
  													__lowercase=    batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
  													__lowercase=    num_proc
  													__lowercase=    'utf-8'
  													__lowercase=    to_csv_kwargs
  
  
  							def     _A (self      ):
  													__lowercase=    self.to_csv_kwargs.pop('path_or_buf'   ,       lowerCAmelCase      )
  													__lowercase=    self.to_csv_kwargs.pop('header'   ,       lowerCAmelCase      )
  													__lowercase=    self.to_csv_kwargs.pop('index'   ,       lowerCAmelCase      )
  
  													if isinstance(self.path_or_buf   ,       (str, bytes, os.PathLike)      ):
  																			with open(self.path_or_buf   ,       'wb+'      ) as buffer:
  																									__lowercase=    self._write(file_obj=lowerCAmelCase   ,       header=lowerCAmelCase   ,       index=lowerCAmelCase   ,       **self.to_csv_kwargs      )
  													else:
  																			__lowercase=    self._write(file_obj=self.path_or_buf   ,       header=lowerCAmelCase   ,       index=lowerCAmelCase   ,       **self.to_csv_kwargs      )
  													return written
  
  
  							def     _A (self   ,       lowerCAmelCase      ):
  													__lowercase,							__lowercase,							__lowercase,							__lowercase=    args
  
  													__lowercase=    query_table(
  													    table=self.dataset.data   ,       key=slice(lowerCAmelCase   ,       offset + self.batch_size      )   ,       indices=self.dataset._indices   ,       )
  													__lowercase=    batch.to_pandas().to_csv(
  													    path_or_buf=lowerCAmelCase   ,       header=header if (offset == 0) else False   ,       index=lowerCAmelCase   ,       **lowerCAmelCase      )
  													return csv_str.encode(self.encoding      )
  
  
  
  
  
  
  
  							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       **lowerCAmelCase      ):
  													__lowercase=    0
  
  													if self.num_proc is None or self.num_proc == 1:
  																			for offset in logging.tqdm(
  																			    range(0   ,       len(self.dataset      )   ,       self.batch_size      )   ,       unit='ba'   ,       disable=not logging.is_progress_bar_enabled()   ,       desc='Creating CSV from Arrow format'   ,       ):
  																									__lowercase=    self._batch_csv((offset, header, index, to_csv_kwargs)      )
  																									written += file_obj.write(lowerCAmelCase      )
  
  													else:
  																			__lowercase,							__lowercase=    len(self.dataset      ), self.batch_size
  																			with multiprocessing.Pool(self.num_proc      ) as pool:
  																									for csv_str in logging.tqdm(
  																									    pool.imap(
  																									        self._batch_csv   ,       [(offset, header, index, to_csv_kwargs) for offset in range(0   ,       lowerCAmelCase   ,       lowerCAmelCase      )]   ,       )   ,       total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size   ,       unit='ba'   ,       disable=not logging.is_progress_bar_enabled()   ,       desc='Creating CSV from Arrow format'   ,       ):
  																															written += file_obj.write(lowerCAmelCase      )
  
  													return written
  
  
  
  
  
  
  
style_context: 
  
  
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  
  
  
  @dataclass
  # Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
  class    A					(     A_				):
  							UpperCamelCase_     :							Union[List[PIL.Image.Image], np.ndarray]
  							UpperCamelCase_     :							Optional[List[bool]]
  
  
  if is_transformers_available() and is_torch_available():
  	from .modeling_roberta_series import RobertaSeriesModelWithTransformation
  	from .pipeline_alt_diffusion import AltDiffusionPipeline
  	from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline
  
  
  
  
  
  
  