code: 
  
  
  
  
  """simple docstring"""
  
  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__    (  lowerCamelCase_			):
  
  
  			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				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					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				, )
  					snake_case		:						str								=				path_or_paths if isinstance(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							) else {self.split: path_or_paths}
  					snake_case		:						Tuple								=				Csv(
  					    cache_dir=SCREAMING_SNAKE_CASE				, data_files=SCREAMING_SNAKE_CASE				, features=SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE				, )
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if self.streaming:
  							snake_case		:						Optional[int]								=				self.builder.as_streaming_dataset(split=self.split							)
  					# Build regular (map-style) dataset
  					else:
  							snake_case		:						int								=				None
  							snake_case		:						int								=				None
  							snake_case		:						str								=				None
  							snake_case		:						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				, )
  							snake_case		:						int								=				self.builder.as_dataset(
  							    split=self.split				, verification_mode=SCREAMING_SNAKE_CASE				, 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				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if num_proc is not None and num_proc <= 0:
  							raise ValueError(F'''num_proc {num_proc} must be an integer > 0.'''							)
  
  					snake_case		:						List[str]								=				dataset
  					snake_case		:						str								=				path_or_buf
  					snake_case		:						Union[str, Any]								=				batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
  					snake_case		:						List[str]								=				num_proc
  					snake_case		:						Dict								=				"utf-8"
  					snake_case		:						Optional[int]								=				to_csv_kwargs
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[str]								=				self.to_csv_kwargs.pop("path_or_buf"				, SCREAMING_SNAKE_CASE							)
  					snake_case		:						str								=				self.to_csv_kwargs.pop("header"				, SCREAMING_SNAKE_CASE							)
  					snake_case		:						Union[str, Any]								=				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:
  									snake_case		:						str								=				self._write(file_obj=SCREAMING_SNAKE_CASE				, header=SCREAMING_SNAKE_CASE				, index=SCREAMING_SNAKE_CASE				, **self.to_csv_kwargs							)
  					else:
  							snake_case		:						int								=				self._write(file_obj=self.path_or_buf				, header=SCREAMING_SNAKE_CASE				, index=SCREAMING_SNAKE_CASE				, **self.to_csv_kwargs							)
  					return written
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				args
  
  					snake_case		:						Union[str, Any]								=				query_table(
  					    table=self.dataset.data				, key=slice(SCREAMING_SNAKE_CASE				, offset + self.batch_size							)				, indices=self.dataset._indices				, )
  					snake_case		:						str								=				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 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				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"				, ):
  									snake_case		:						List[str]								=				self._batch_csv((offset, header, index, to_csv_kwargs)							)
  									written += file_obj.write(SCREAMING_SNAKE_CASE							)
  
  					else:
  							snake_case		:						Optional[Any]								=				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: 
  
  
  
  
  """simple docstring"""
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Tuple								=     ["""image_processor""", """tokenizer"""]
  			a__ :      List[Any]								=     """EfficientNetImageProcessor"""
  			a__ :      str								=     ("""BertTokenizer""", """BertTokenizerFast""")
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					super().__init__(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							)
  
  
  			def __call__(     self				, SCREAMING_SNAKE_CASE=None				, SCREAMING_SNAKE_CASE=None				, SCREAMING_SNAKE_CASE="max_length"				, SCREAMING_SNAKE_CASE=64				, SCREAMING_SNAKE_CASE=None				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if text is None and images is None:
  							raise ValueError("You have to specify either text or images. Both cannot be none."							)
  
  					if text is not None:
  							snake_case		:						Dict								=				self.tokenizer(
  							    SCREAMING_SNAKE_CASE				, padding=SCREAMING_SNAKE_CASE				, max_length=SCREAMING_SNAKE_CASE				, return_tensors=SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  					if images is not None:
  							snake_case		:						Tuple								=				self.image_processor(SCREAMING_SNAKE_CASE				, return_tensors=SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  					if text is not None and images is not None:
  							snake_case		:						Dict								=				image_features.pixel_values
  							return encoding
  					elif text is not None:
  							return encoding
  					else:
  							return BatchEncoding(data=dict(**SCREAMING_SNAKE_CASE							)				, tensor_type=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self				, *SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self				, *SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.tokenizer.decode(*SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  
  
  			@property
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[Any]								=				self.tokenizer.model_input_names
  					snake_case		:						Any								=				self.image_processor.model_input_names
  					return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names							)							)
  
  