






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


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

@dataclass
class        snake_case_				(							datasets.BuilderConfig   ):







   """simple docstring"""



   __lowerCAmelCase  =    None
   __lowerCAmelCase  =    "utf-8"
   __lowerCAmelCase  =    None
   __lowerCAmelCase  =    10 << 20  # 10MB
   __lowerCAmelCase  =    False
   __lowerCAmelCase  =    "line"






class        snake_case_				(							datasets.ArrowBasedBuilder   ):







   """simple docstring"""



   __lowerCAmelCase  =    TextConfig

   def       SCREAMING_SNAKE_CASE__					(     self:						Dict						)	->		List[Any]:


       """simple docstring"""



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

   def       SCREAMING_SNAKE_CASE__					(     self:						Optional[Any] ,							snake_case__:						str						)	->		Dict:


       """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}'''						)
       _lowercase     			=						dl_manager.download_and_extract(self.config.data_files						)
       if isinstance(snake_case__ ,							(str, list, tuple)						):
           _lowercase     			=						data_files
           if isinstance(snake_case__ ,							snake_case__						):
               _lowercase     			=						[files]
           _lowercase     			=						[dl_manager.iter_files(snake_case__						) for file in files]
           return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,							gen_kwargs={'files': files}						)]
       _lowercase     			=						[]
       for split_name, files in data_files.items():
           if isinstance(snake_case__ ,							snake_case__						):
               _lowercase     			=						[files]
           _lowercase     			=						[dl_manager.iter_files(snake_case__						) for file in files]
           splits.append(datasets.SplitGenerator(name=snake_case__ ,							gen_kwargs={'files': files}						)						)
       return splits

   def       SCREAMING_SNAKE_CASE__					(     self:						List[str] ,							snake_case__:						pa.Table						)	->		pa.Table:


       """simple docstring"""



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

   def       SCREAMING_SNAKE_CASE__					(     self:						Any ,							snake_case__:						str						)	->		Tuple:


       """simple docstring"""



       _lowercase     			=						list(self.config.features						) if self.config.features is not None else ['text']
       for file_idx, file in enumerate(itertools.chain.from_iterable(snake_case__						)						):
           # open in text mode, by default translates universal newlines ("\n", "\r\n" and "\r") into "\n"
           with open(snake_case__ ,							encoding=self.config.encoding ,							errors=self.config.errors						) as f:
               if self.config.sample_by == "line":
                   _lowercase     			=						0
                   while True:
                       _lowercase     			=						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)
                       _lowercase     			=						StringIO(snake_case__						).readlines()
                       if not self.config.keep_linebreaks:
                           _lowercase     			=						[line.rstrip('\n'						) for line in batch]
                       _lowercase     			=						pa.Table.from_arrays([pa.array(snake_case__						)] ,							names=snake_case__						)
                       # 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(snake_case__						)
                       batch_idx += 1
               elif self.config.sample_by == "paragraph":
                   _lowercase     			=						0
                   _lowercase     			=						''
                   while True:
                       _lowercase     			=						f.read(self.config.chunksize						)
                       if not new_batch:
                           break
                       batch += new_batch
                       batch += f.readline()  # finish current line
                       _lowercase     			=						batch.split('\n\n'						)
                       _lowercase     			=						pa.Table.from_arrays(
                           [pa.array([example for example in batch[:-1] if example]						)] ,							names=snake_case__						)
                       # 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(snake_case__						)
                       batch_idx += 1
                       _lowercase     			=						batch[-1]
                   if batch:
                       _lowercase     			=						pa.Table.from_arrays([pa.array([batch]						)] ,							names=snake_case__						)
                       yield (file_idx, batch_idx), self._cast_table(snake_case__						)
               elif self.config.sample_by == "document":
                   _lowercase     			=						f.read()
                   _lowercase     			=						pa.Table.from_arrays([pa.array([text]						)] ,							names=snake_case__						)
                   yield file_idx, self._cast_table(snake_case__						)








import math
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						math.log(2,   10   ) * number
    _lowercase     			=						round((log_number - int(_lowercase   )),   15   )

    return difference
def 							UpperCAmelCase   ( _lowercase = 678910   ):


    '''simple docstring'''



    _lowercase     			=						90
    _lowercase     			=						0

    _lowercase     			=						math.log(1.23,   10   )
    _lowercase     			=						math.log(1.24,   10   )
    _lowercase     			=						0

    while position < number:
        _lowercase     			=						log_difference(_lowercase   )

        if difference >= upper_limit:
            power_iterator += 93

        elif difference < lower_limit:
            power_iterator += 196

        else:
            _lowercase     			=						power_iterator
            power_iterator += 196
            position += 1

    return previous_power


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(f"{solution() = }")
