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        lowerCAmelCase_	(						a__							):
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = False,    SCREAMING_SNAKE_CASE_ = False,    SCREAMING_SNAKE_CASE_ = None,    **SCREAMING_SNAKE_CASE_,    )  ->	Dict:
            super().__init__(
                UpperCamelCase_,    split=UpperCamelCase_,    features=UpperCamelCase_,    cache_dir=UpperCamelCase_,    keep_in_memory=UpperCamelCase_,    streaming=UpperCamelCase_,    num_proc=UpperCamelCase_,    **UpperCamelCase_,    )
            UpperCamelCase					:						List[Any]					=			path_or_paths if isinstance(UpperCamelCase_,    UpperCamelCase_ ) else {self.split: path_or_paths}
            UpperCamelCase					:						Union[str, Any]					=			Csv(
                cache_dir=UpperCamelCase_,    data_files=UpperCamelCase_,    features=UpperCamelCase_,    **UpperCamelCase_,    )
  
  
  
  
  
  
         def       snake_case_ (    self )  ->	Any:
            # Build iterable dataset
            if self.streaming:
               UpperCamelCase					:						List[Any]					=			self.builder.as_streaming_dataset(split=self.split )
            # Build regular (map-style) dataset
            else:
               UpperCamelCase					:						Any					=			None
               UpperCamelCase					:						List[Any]					=			None
               UpperCamelCase					:						Optional[int]					=			None
               UpperCamelCase					:						Tuple					=			None
  
               self.builder.download_and_prepare(
                   download_config=UpperCamelCase_,    download_mode=UpperCamelCase_,    verification_mode=UpperCamelCase_,    base_path=UpperCamelCase_,    num_proc=self.num_proc,    )
               UpperCamelCase					:						str					=			self.builder.as_dataset(
                   split=self.split,    verification_mode=UpperCamelCase_,    in_memory=self.keep_in_memory )
            return dataset
  
  
  
  
  
  
  class        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = None,    SCREAMING_SNAKE_CASE_ = None,    **SCREAMING_SNAKE_CASE_,    )  ->	List[str]:
            if num_proc is not None and num_proc <= 0:
               raise ValueError(F"""num_proc {num_proc} must be an integer > 0.""" )
  
            UpperCamelCase					:						Dict					=			dataset
            UpperCamelCase					:						Any					=			path_or_buf
            UpperCamelCase					:						Union[str, Any]					=			batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
            UpperCamelCase					:						int					=			num_proc
            UpperCamelCase					:						List[str]					=			'utf-8'
            UpperCamelCase					:						str					=			to_csv_kwargs
         def       snake_case_ (    self )  ->	str:
            UpperCamelCase					:						Dict					=			self.to_csv_kwargs.pop('path_or_buf',    UpperCamelCase_ )
            UpperCamelCase					:						Union[str, Any]					=			self.to_csv_kwargs.pop('header',    UpperCamelCase_ )
            UpperCamelCase					:						List[str]					=			self.to_csv_kwargs.pop('index',    UpperCamelCase_ )
  
            if isinstance(self.path_or_buf,    (str, bytes, os.PathLike) ):
               with open(self.path_or_buf,    'wb+' ) as buffer:
                  UpperCamelCase					:						List[Any]					=			self._write(file_obj=UpperCamelCase_,    header=UpperCamelCase_,    index=UpperCamelCase_,    **self.to_csv_kwargs )
            else:
               UpperCamelCase					:						List[Any]					=			self._write(file_obj=self.path_or_buf,    header=UpperCamelCase_,    index=UpperCamelCase_,    **self.to_csv_kwargs )
            return written
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	Tuple:
            UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			args
  
            UpperCamelCase					:						List[str]					=			query_table(
                table=self.dataset.data,    key=slice(UpperCamelCase_,    offset + self.batch_size ),    indices=self.dataset._indices,    )
            UpperCamelCase					:						Any					=			batch.to_pandas().to_csv(
                path_or_buf=UpperCamelCase_,    header=header if (offset == 0) else False,    index=UpperCamelCase_,    **UpperCamelCase_ )
            return csv_str.encode(self.encoding )
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_ )  ->	Tuple:
            UpperCamelCase					:						List[Any]					=			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',    ):
                  UpperCamelCase					:						Any					=			self._batch_csv((offset, header, index, to_csv_kwargs) )
                  written += file_obj.write(UpperCamelCase_ )
  
            else:
               UpperCamelCase			,  UpperCamelCase					:						str					=			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,    UpperCamelCase_,    UpperCamelCase_ )],    ),    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(UpperCamelCase_ )
  
            return written
  
  
  
  
style_context: 
  
  
  
  from typing import Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_openai import OpenAIGPTTokenizer
  
  
  __UpperCAmelCase      = logging.get_logger(__name__)
  
  __UpperCAmelCase      = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}
  
  __UpperCAmelCase      = {
      '''vocab_file''': {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/vocab.json'''},
      '''merges_file''': {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/merges.txt'''},
      '''tokenizer_file''': {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/tokenizer.json'''},
  }
  
  __UpperCAmelCase      = {
      '''openai-gpt''': 512,
  }
  
  
  
  class        lowerCAmelCase_	(						a__							):
         UpperCAmelCase__       :      Union[str, Any]       =						VOCAB_FILES_NAMES
         UpperCAmelCase__       :      int       =						PRETRAINED_VOCAB_FILES_MAP
         UpperCAmelCase__       :      Optional[int]       =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
         UpperCAmelCase__       :      Optional[int]       =						["input_ids", "attention_mask"]
         UpperCAmelCase__       :      Tuple       =						OpenAIGPTTokenizer
         def __init__(    self,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_="<unk>",    **SCREAMING_SNAKE_CASE_ )  ->	List[str]:
            super().__init__(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    tokenizer_file=SCREAMING_SNAKE_CASE_,    unk_token=SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_ )
         @property
         def       snake_case_ (    self )  ->	Dict:
            return True
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = None )  ->	Tuple[str]:
            UpperCamelCase					:						List[Any]					=			self._tokenizer.model.save(SCREAMING_SNAKE_CASE_,    name=SCREAMING_SNAKE_CASE_ )
            return tuple(SCREAMING_SNAKE_CASE_ )
  
  
  
  