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     UpperCAmelCase_		(      _UpperCAmelCase				):
  
  
  
        """simple docstring"""
        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_					,       )       ->   List[Any]:
            super().__init__(
                SCREAMING_SNAKE_CASE_					,       split=SCREAMING_SNAKE_CASE_					,       features=SCREAMING_SNAKE_CASE_					,       cache_dir=SCREAMING_SNAKE_CASE_					,       keep_in_memory=SCREAMING_SNAKE_CASE_					,       streaming=SCREAMING_SNAKE_CASE_					,       num_proc=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_					,       )
            UpperCamelCase :List[Any]										=     path_or_paths if isinstance(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				) else {self.split: path_or_paths}
            UpperCamelCase :Tuple										=     Csv(
                cache_dir=SCREAMING_SNAKE_CASE_					,       data_files=SCREAMING_SNAKE_CASE_					,       features=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_					,       )
  
  
  
  
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
  
  
  
  
  
  
            if self.streaming:
                UpperCamelCase :Dict										=     self.builder.as_streaming_dataset(split=self.split				)
            # Build regular (map-style) dataset
            else:
                UpperCamelCase :int										=     None
                UpperCamelCase :List[str]										=     None
                UpperCamelCase :int										=     None
                UpperCamelCase :List[Any]										=     None
  
                self.builder.download_and_prepare(
                    download_config=SCREAMING_SNAKE_CASE_					,       download_mode=SCREAMING_SNAKE_CASE_					,       verification_mode=SCREAMING_SNAKE_CASE_					,       base_path=SCREAMING_SNAKE_CASE_					,       num_proc=self.num_proc					,       )
                UpperCamelCase :Optional[int]										=     self.builder.as_dataset(
                    split=self.split					,       verification_mode=SCREAMING_SNAKE_CASE_					,       in_memory=self.keep_in_memory				)
            return dataset
  
  
  
  
  
  
  
  class     UpperCAmelCase_		:
  
  
  
        """simple docstring"""
        def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       **SCREAMING_SNAKE_CASE_					,       )       ->   Dict:
  
  
  
  
  
  
            if num_proc is not None and num_proc <= 0:
                raise ValueError(F'''num_proc {num_proc} must be an integer > 0.'''				)
  
            UpperCamelCase :Any										=     dataset
            UpperCamelCase :str										=     path_or_buf
            UpperCamelCase :str										=     batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
            UpperCamelCase :List[str]										=     num_proc
            UpperCamelCase :List[Any]										=     '''utf-8'''
            UpperCamelCase :int										=     to_csv_kwargs
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase :List[str]										=     self.to_csv_kwargs.pop('''path_or_buf'''					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Optional[int]										=     self.to_csv_kwargs.pop('''header'''					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :str										=     self.to_csv_kwargs.pop('''index'''					,       SCREAMING_SNAKE_CASE_				)
  
            if isinstance(self.path_or_buf					,       (str, bytes, os.PathLike)				):
                with open(self.path_or_buf					,       '''wb+'''				) as buffer:
                    UpperCamelCase :Union[str, Any]										=     self._write(file_obj=SCREAMING_SNAKE_CASE_					,       header=SCREAMING_SNAKE_CASE_					,       index=SCREAMING_SNAKE_CASE_					,       **self.to_csv_kwargs				)
            else:
                UpperCamelCase :Optional[Any]										=     self._write(file_obj=self.path_or_buf					,       header=SCREAMING_SNAKE_CASE_					,       index=SCREAMING_SNAKE_CASE_					,       **self.to_csv_kwargs				)
            return written
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_				)       ->   Optional[int]:
            UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Tuple										=     args
  
            UpperCamelCase :Union[str, Any]										=     query_table(
                table=self.dataset.data					,       key=slice(SCREAMING_SNAKE_CASE_					,       offset + self.batch_size				)					,       indices=self.dataset._indices					,       )
            UpperCamelCase :Dict										=     batch.to_pandas().to_csv(
                path_or_buf=SCREAMING_SNAKE_CASE_					,       header=header if (offset == 0) else False					,       index=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
            return csv_str.encode(self.encoding				)
  
  
  
  
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)       ->   int:
            UpperCamelCase :int										=     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 :Tuple										=     self._batch_csv((offset, header, index, to_csv_kwargs)				)
                    written += file_obj.write(SCREAMING_SNAKE_CASE_				)
  
            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					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)]					,       )					,       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(SCREAMING_SNAKE_CASE_				)
  
            return written
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  from typing import Generic, TypeVar
  
  __snake_case							      =						TypeVar("""T""")
  
  
  
  
  
  
  
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        pass
  
  
  
  
  
  
  
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        pass
  
  
  
  
  
  
  
  class     UpperCAmelCase_		(      Generic[T]				):
  
  
  
        """simple docstring"""
        def __init__(       self					,       SCREAMING_SNAKE_CASE_ = 10				)       ->   List[str]:
            UpperCamelCase :list[T]										=     []
            UpperCamelCase :Any										=     limit
        def __bool__(       self				)       ->   bool:
            return bool(self.stack				)
        def __str__(       self				)       ->   str:
            return str(self.stack				)
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_				)       ->   None:
            if len(self.stack				) >= self.limit:
                raise StackOverflowError
            self.stack.append(SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   T:
            if not self.stack:
                raise StackUnderflowError
            return self.stack.pop()
        def 					UpperCAmelCase		(       self				)       ->   T:
            if not self.stack:
                raise StackUnderflowError
            return self.stack[-1]
        def 					UpperCAmelCase		(       self				)       ->   bool:
            return not bool(self.stack				)
        def 					UpperCAmelCase		(       self				)       ->   bool:
            return self.size() == self.limit
        def 					UpperCAmelCase		(       self				)       ->   int:
            return len(self.stack				)
  
  
  
  
        def __contains__(       self					,       SCREAMING_SNAKE_CASE_				)       ->   bool:
            return item in self.stack
  
  
  
  
  
  
  
  def 						_A     (       ):
      UpperCamelCase :Stack[int]										=     Stack(10 )
      assert bool(SCREAMING_SNAKE_CASE__ ) is False
      assert stack.is_empty() is True
      assert stack.is_full() is False
      assert str(SCREAMING_SNAKE_CASE__ ) == "[]"
  
      try:
          UpperCamelCase :Optional[int]										=     stack.pop()
          raise AssertionError  # This should not happen
      except StackUnderflowError:
          assert True  # This should happen
  
      try:
          UpperCamelCase :Union[str, Any]										=     stack.peek()
          raise AssertionError  # This should not happen
      except StackUnderflowError:
          assert True  # This should happen
  
      for i in range(10 ):
          assert stack.size() == i
          stack.push(SCREAMING_SNAKE_CASE__ )
  
      assert bool(SCREAMING_SNAKE_CASE__ )
      assert not stack.is_empty()
      assert stack.is_full()
      assert str(SCREAMING_SNAKE_CASE__ ) == str(list(range(10 ) ) )
      assert stack.pop() == 9
      assert stack.peek() == 8
  
      stack.push(100 )
      assert str(SCREAMING_SNAKE_CASE__ ) == str([0, 1, 2, 3, 4, 5, 6, 7, 8, 100] )
  
      try:
          stack.push(200 )
          raise AssertionError  # This should not happen
      except StackOverflowError:
          assert True  # This should happen
  
      assert not stack.is_empty()
      assert stack.size() == 10
  
      assert 5 in stack
      assert 55 not in stack
  
  
  if __name__ == "__main__":
   test_stack()
  
  
  
  
  
  