





'''simple docstring'''




import itertools
from dataclasses import dataclass
from io import StringIO
from typing import Optional

import pyarrow as pa

import datasets
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


__UpperCAmelCase         =   datasets.utils.logging.get_logger(__name__)




@dataclass
class       UpperCamelCase__			(			datasets.BuilderConfig	):




     """simple docstring"""
     SCREAMING_SNAKE_CASE__						=					None
     SCREAMING_SNAKE_CASE__						=					'''utf-8'''
     SCREAMING_SNAKE_CASE__						=					None
     SCREAMING_SNAKE_CASE__						=					10 << 20  # 10MB
     SCREAMING_SNAKE_CASE__						=					False
     SCREAMING_SNAKE_CASE__						=					'''line'''







class       UpperCamelCase__			(			datasets.ArrowBasedBuilder	):




     """simple docstring"""
     SCREAMING_SNAKE_CASE__						=					TextConfig


     def lowerCamelCase_	(		self							:	int		):

       '''simple docstring'''



       return datasets.DatasetInfo(features=self.config.features		)


     def lowerCamelCase_	(		self							:	Optional[Any]     ,		lowerCamelCase_							:	str		):

       '''simple docstring'''



       if not self.config.data_files:
         raise ValueError(f'''At least one data file must be specified, but got data_files={self.config.data_files}'''		)
       SCREAMING_SNAKE_CASE				:							List[str]						=	dl_manager.download_and_extract(self.config.data_files		)
       if isinstance(lowerCamelCase_     ,		(str, list, tuple)		):
         SCREAMING_SNAKE_CASE				:							int						=	data_files
         if isinstance(lowerCamelCase_     ,		lowerCamelCase_		):
           SCREAMING_SNAKE_CASE				:							List[Any]						=	[files]
         SCREAMING_SNAKE_CASE				:							Tuple						=	[dl_manager.iter_files(lowerCamelCase_		) for file in files]
         return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,		gen_kwargs={"""files""": files}		)]
       SCREAMING_SNAKE_CASE				:							Optional[Any]						=	[]
       for split_name, files in data_files.items():
         if isinstance(lowerCamelCase_     ,		lowerCamelCase_		):
           SCREAMING_SNAKE_CASE				:							int						=	[files]
         SCREAMING_SNAKE_CASE				:							Tuple						=	[dl_manager.iter_files(lowerCamelCase_		) for file in files]
         splits.append(datasets.SplitGenerator(name=lowerCamelCase_     ,		gen_kwargs={"""files""": files}		)		)
       return splits


     def lowerCamelCase_	(		self							:	Any     ,		lowerCamelCase_							:	pa.Table		):

       '''simple docstring'''



       if self.config.features is not None:
         SCREAMING_SNAKE_CASE				:							Dict						=	self.config.features.arrow_schema
         if all(not require_storage_cast(lowerCamelCase_		) for feature in self.config.features.values()		):
           # cheaper cast
           SCREAMING_SNAKE_CASE				:							Any						=	pa_table.cast(lowerCamelCase_		)
         else:
           # more expensive cast; allows str <-> int/float or str to Audio for example
           SCREAMING_SNAKE_CASE				:							int						=	table_cast(lowerCamelCase_     ,		lowerCamelCase_		)
         return pa_table
       else:
         return pa_table.cast(pa.schema({"""text""": pa.string()}		)		)



     def lowerCamelCase_	(		self							:	List[Any]     ,		lowerCamelCase_							:	Optional[Any]		):

       '''simple docstring'''



       SCREAMING_SNAKE_CASE				:							List[str]						=	list(self.config.features		) if self.config.features is not None else ["""text"""]
       for file_idx, file in enumerate(itertools.chain.from_iterable(lowerCamelCase_		)		):
         # open in text mode, by default translates universal newlines ("\n", "\r\n" and "\r") into "\n"
         with open(lowerCamelCase_     ,		encoding=self.config.encoding     ,		errors=self.config.errors		) as f:
           if self.config.sample_by == "line":
             SCREAMING_SNAKE_CASE				:							Any						=	0
             while True:
               SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	f.read(self.config.chunksize		)
               if not batch:
                 break
               batch += f.readline()  # finish current line
               # StringIO.readlines, by default splits only on "\n" (and keeps line breaks)
               SCREAMING_SNAKE_CASE				:							Any						=	StringIO(lowerCamelCase_		).readlines()
               if not self.config.keep_linebreaks:
                 SCREAMING_SNAKE_CASE				:							Any						=	[line.rstrip("""\n"""		) for line in batch]
               SCREAMING_SNAKE_CASE				:							Optional[Any]						=	pa.Table.from_arrays([pa.array(lowerCamelCase_		)]     ,		names=lowerCamelCase_		)
               # Uncomment for debugging (will print the Arrow table size and elements)
               # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
               # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
               yield (file_idx, batch_idx), self._cast_table(lowerCamelCase_		)
               batch_idx += 1
           elif self.config.sample_by == "paragraph":
             SCREAMING_SNAKE_CASE				:							Any						=	0
             SCREAMING_SNAKE_CASE				:							int						=	""""""
             while True:
               SCREAMING_SNAKE_CASE				:							List[str]						=	f.read(self.config.chunksize		)
               if not new_batch:
                 break
               batch += new_batch
               batch += f.readline()  # finish current line
               SCREAMING_SNAKE_CASE				:							List[Any]						=	batch.split("""\n\n"""		)
               SCREAMING_SNAKE_CASE				:							str						=	pa.Table.from_arrays(
                   [pa.array([example for example in batch[:-1] if example]		)]     ,		names=lowerCamelCase_		)
               # Uncomment for debugging (will print the Arrow table size and elements)
               # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
               # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
               yield (file_idx, batch_idx), self._cast_table(lowerCamelCase_		)
               batch_idx += 1
               SCREAMING_SNAKE_CASE				:							int						=	batch[-1]
             if batch:
               SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	pa.Table.from_arrays([pa.array([batch]		)]     ,		names=lowerCamelCase_		)
               yield (file_idx, batch_idx), self._cast_table(lowerCamelCase_		)
           elif self.config.sample_by == "document":
             SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	f.read()
             SCREAMING_SNAKE_CASE				:							Optional[int]						=	pa.Table.from_arrays([pa.array([text]		)]     ,		names=lowerCamelCase_		)
             yield file_idx, self._cast_table(lowerCamelCase_		)










'''simple docstring'''




from __future__ import annotations



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							List[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 						__A						(       ):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	[[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
		SCREAMING_SNAKE_CASE				:							Dict						=	int(input("""Enter the element to be searched:"""					)					)
		print(lowerCamelCase_					)
		search_in_a_sorted_matrix(lowerCamelCase_	,	len(lowerCamelCase_					)	,	len(mat[0]					)	,	lowerCamelCase_					)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()



