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		(     UpperCamelCase__	):
  
  
  
  
  				def __init__( self		,		snake_case_		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = None		,		snake_case_ = False		,		snake_case_ = False		,		snake_case_ = None		,		**snake_case_		,		)    ->      List[Any]:
  											super().__init__(
  											    snake_case_		,		split=snake_case_		,		features=snake_case_		,		cache_dir=snake_case_		,		keep_in_memory=snake_case_		,		streaming=snake_case_		,		num_proc=snake_case_		,		**snake_case_		,		)
  											SCREAMING_SNAKE_CASE			: Any	     =path_or_paths if isinstance(snake_case_		,		snake_case_							) else {self.split: path_or_paths}
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =Csv(
  											    cache_dir=snake_case_		,		data_files=snake_case_		,		features=snake_case_		,		**snake_case_		,		)
  
  
  
  
  
  
  
  				def     __a		( self							)    ->      str:
  
  
  
  
  
  
  											if self.streaming:
  																		SCREAMING_SNAKE_CASE			: str	     =self.builder.as_streaming_dataset(split=self.split							)
  											# Build regular (map-style) dataset
  											else:
  																		SCREAMING_SNAKE_CASE			: int	     =None
  																		SCREAMING_SNAKE_CASE			: Dict	     =None
  																		SCREAMING_SNAKE_CASE			: Dict	     =None
  																		SCREAMING_SNAKE_CASE			: Union[str, Any]	     =None
  
  																		self.builder.download_and_prepare(
  																		    download_config=snake_case_		,		download_mode=snake_case_		,		verification_mode=snake_case_		,		base_path=snake_case_		,		num_proc=self.num_proc		,		)
  																		SCREAMING_SNAKE_CASE			: Dict	     =self.builder.as_dataset(
  																		    split=self.split		,		verification_mode=snake_case_		,		in_memory=self.keep_in_memory							)
  											return dataset
  
  
  
  
  
  
  
  class 							_lowerCAmelCase		:
  
  
  
  
  				def __init__( self		,		snake_case_		,		snake_case_		,		snake_case_ = None		,		snake_case_ = None		,		**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.'							)
  
  											SCREAMING_SNAKE_CASE			: Dict	     =dataset
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =path_or_buf
  											SCREAMING_SNAKE_CASE			: List[str]	     =batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =num_proc
  											SCREAMING_SNAKE_CASE			: int	     ="utf-8"
  											SCREAMING_SNAKE_CASE			: List[Any]	     =to_csv_kwargs
  
  
  
  
  				def     __a		( self							)    ->      int:
  											SCREAMING_SNAKE_CASE			: int	     =self.to_csv_kwargs.pop('''path_or_buf'''		,		snake_case_							)
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =self.to_csv_kwargs.pop('''header'''		,		snake_case_							)
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =self.to_csv_kwargs.pop('''index'''		,		snake_case_							)
  
  											if isinstance(self.path_or_buf		,		(str, bytes, os.PathLike)							):
  																		with open(self.path_or_buf		,		'''wb+'''							) as buffer:
  																									SCREAMING_SNAKE_CASE			: str	     =self._write(file_obj=snake_case_		,		header=snake_case_		,		index=snake_case_		,		**self.to_csv_kwargs							)
  											else:
  																		SCREAMING_SNAKE_CASE			: Union[str, Any]	     =self._write(file_obj=self.path_or_buf		,		header=snake_case_		,		index=snake_case_		,		**self.to_csv_kwargs							)
  											return written
  
  
  
  
  				def     __a		( self		,		snake_case_							)    ->      Union[str, Any]:
  											SCREAMING_SNAKE_CASE			: Optional[int]	     =args
  
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =query_table(
  											    table=self.dataset.data		,		key=slice(snake_case_		,		offset + self.batch_size							)		,		indices=self.dataset._indices		,		)
  											SCREAMING_SNAKE_CASE			: Dict	     =batch.to_pandas().to_csv(
  											    path_or_buf=snake_case_		,		header=header if (offset == 0) else False		,		index=snake_case_		,		**snake_case_							)
  											return csv_str.encode(self.encoding							)
  
  
  
  
  
  
  
  				def     __a		( self		,		snake_case_		,		snake_case_		,		snake_case_		,		**snake_case_							)    ->      int:
  											SCREAMING_SNAKE_CASE			: 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'''		,		):
  																									SCREAMING_SNAKE_CASE			: int	     =self._batch_csv((offset, header, index, to_csv_kwargs)							)
  																									written += file_obj.write(snake_case_							)
  
  											else:
  																		SCREAMING_SNAKE_CASE			: Dict	     =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		,		snake_case_		,		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(snake_case_							)
  
  											return written
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  from __future__ import annotations
  def 						lowerCAmelCase_       (	__a	,	__a	,	__a	,	__a )       ->			None:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE			: Any	     =m - 1, 0
  							while i >= 0 and j < n:
  														if key == mat[i][j]:
  																					print(f'Key {key} found at row- {i + 1} column- {j + 1}' )
  																					return
  														if key < mat[i][j]:
  																					i -= 1
  														else:
  																					j += 1
  							print(f'Key {key} not found' )
  def 						lowerCAmelCase_       (	)       ->			None:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							SCREAMING_SNAKE_CASE			: int	     =[[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
  							SCREAMING_SNAKE_CASE			: List[str]	     =int(input('''Enter the element to be searched:''' ) )
  							print(__a )
  							search_in_a_sorted_matrix(__a	,	len(__a )	,	len(mat[0] )	,	__a )
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()
  							main()
  
  
  
  
  
  
  