



import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


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







@dataclass
class 		snake_case						(	datasets.BuilderConfig  ):



   '''simple docstring'''






   snake_case_					: int          =		1_00_00
   snake_case_					: Optional[List[str]]          =		None
   snake_case_					: Optional[datasets.Features]          =		None







class 		snake_case						(	datasets.ArrowBasedBuilder  ):



   '''simple docstring'''






   snake_case_					: Optional[int]          =		ParquetConfig

   def      UpperCamelCase_  (					self							:			Optional[Any])				->				str:

    """simple docstring"""







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

   def      UpperCamelCase_  (					self							:			Union[str, Any]				,		lowerCAmelCase							:			Dict)				->				Any:

    """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}''')
    _snake_case    :  Tuple					=					dl_manager.download_and_extract(self.config.data_files)
    if isinstance(lowerCAmelCase				,		(str, list, tuple)):
     _snake_case    :  Optional[Any]					=					data_files
     if isinstance(lowerCAmelCase				,		lowerCAmelCase):
      _snake_case    :  List[str]					=					[files]
     # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
     _snake_case    :  List[Any]					=					[dl_manager.iter_files(lowerCAmelCase) for file in files]
     return [datasets.SplitGenerator(name=datasets.Split.TRAIN				,		gen_kwargs={"""files""": files})]
    _snake_case    :  List[str]					=					[]
    for split_name, files in data_files.items():
     if isinstance(lowerCAmelCase				,		lowerCAmelCase):
      _snake_case    :  Optional[Any]					=					[files]
     # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
     _snake_case    :  int					=					[dl_manager.iter_files(lowerCAmelCase) for file in files]
     # Infer features is they are stoed in the arrow schema
     if self.info.features is None:
      for file in itertools.chain.from_iterable(lowerCAmelCase):
       with open(lowerCAmelCase				,		"""rb""") as f:
        _snake_case    :  Optional[Any]					=					datasets.Features.from_arrow_schema(pq.read_schema(lowerCAmelCase))
       break
     splits.append(datasets.SplitGenerator(name=lowerCAmelCase				,		gen_kwargs={"""files""": files}))
    return splits

   def      UpperCamelCase_  (					self							:			Any				,		lowerCAmelCase							:			pa.Table)				->				pa.Table:

    """simple docstring"""







    if self.info.features is not None:
     # more expensive cast to support nested features with keys in a different order
     # allows str <-> int/float or str to Audio for example
     _snake_case    :  Tuple					=					table_cast(lowerCAmelCase				,		self.info.features.arrow_schema)
    return pa_table


   def      UpperCamelCase_  (					self							:			Tuple				,		lowerCAmelCase							:			Union[str, Any])				->				Dict:

    """simple docstring"""







    _snake_case    :  List[str]					=					self.info.features.arrow_schema if self.info.features is not None else None
    if self.info.features is not None and self.config.columns is not None:
     if sorted(field.name for field in schema) != sorted(self.config.columns):
      raise ValueError(
          F'''Tried to load parquet data with columns \'{self.config.columns}\' with mismatching features \'{self.info.features}\'''')
    for file_idx, file in enumerate(itertools.chain.from_iterable(lowerCAmelCase)):
     with open(lowerCAmelCase				,		"""rb""") as f:
      _snake_case    :  str					=					pq.ParquetFile(lowerCAmelCase)
      try:
       for batch_idx, record_batch in enumerate(
           parquet_file.iter_batches(batch_size=self.config.batch_size				,		columns=self.config.columns)):
        _snake_case    :  int					=					pa.Table.from_batches([record_batch])
        # 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 F'''{file_idx}_{batch_idx}''', self._cast_table(lowerCAmelCase)
      except ValueError as e:
       logger.error(F'''Failed to read file \'{file}\' with error {type(lowerCAmelCase)}: {e}''')
       raise





from math import ceil, sqrt



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	int = 1_000_000				)  ->     int:
 _snake_case    :  Tuple					=					0

 for outer_width in range(3				,       (limit // 4) + 2				):
  if outer_width**2 > limit:
   _snake_case    :  int					=					max(ceil(sqrt(outer_width**2 - limit				)				)				,       1				)
  else:
   _snake_case    :  Any					=					1
  if (outer_width - hole_width_lower_bound) % 2:
   hole_width_lower_bound += 1

  answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

 return answer


if __name__ == "__main__":
  print(F'''{solution() = }''')
