


'''simple docstring'''


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


UpperCAmelCase_						:  str				  =						datasets.utils.logging.get_logger(__name__)





@dataclass
class        lowercase__    (		datasets.BuilderConfig   ):





							'''simple docstring'''


							A_				: int       =    1_0000
							A_				: Optional[List[str]]       =    None
							A_				: Optional[datasets.Features]       =    None





class        lowercase__    (		datasets.ArrowBasedBuilder   ):





							'''simple docstring'''


							A_				: Union[str, Any]       =    ParquetConfig






							def UpperCAmelCase_      (       self    ):
											return datasets.DatasetInfo(features=self.config.features    )






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											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					:			Tuple							= dl_manager.download_and_extract(self.config.data_files    )
											if isinstance(__snake_case       ,   (str, list, tuple)    ):
															_SCREAMING_SNAKE_CASE					:			Dict							= data_files
															if isinstance(__snake_case       ,   __snake_case    ):
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= [files]
															# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
															_SCREAMING_SNAKE_CASE					:			str							= [dl_manager.iter_files(__snake_case    ) for file in files]
															return [datasets.SplitGenerator(name=datasets.Split.TRAIN       ,   gen_kwargs={"""files""": files}    )]
											_SCREAMING_SNAKE_CASE					:			Dict							= []
											for split_name, files in data_files.items():
															if isinstance(__snake_case       ,   __snake_case    ):
																			_SCREAMING_SNAKE_CASE					:			Tuple							= [files]
															# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
															_SCREAMING_SNAKE_CASE					:			int							= [dl_manager.iter_files(__snake_case    ) 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(__snake_case    ):
																							with open(__snake_case       ,   """rb"""    ) as f:
																											_SCREAMING_SNAKE_CASE					:			Optional[int]							= datasets.Features.from_arrow_schema(pq.read_schema(__snake_case    )    )
																							break
															splits.append(datasets.SplitGenerator(name=__snake_case       ,   gen_kwargs={"""files""": files}    )    )
											return splits






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											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
															_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= table_cast(__snake_case       ,   self.info.features.arrow_schema    )
											return pa_table






							def UpperCAmelCase_      (       self       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= 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(__snake_case    )    ):
															with open(__snake_case       ,   """rb"""    ) as f:
																			_SCREAMING_SNAKE_CASE					:			Any							= pq.ParquetFile(__snake_case    )
																			try:
																							for batch_idx, record_batch in enumerate(
																							    parquet_file.iter_batches(batch_size=self.config.batch_size       ,   columns=self.config.columns    )    ):
																											_SCREAMING_SNAKE_CASE					:			str							= 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(__snake_case    )
																			except ValueError as e:
																							logger.error(f"""Failed to read file '{file}' with error {type(__snake_case    )}: {e}"""    )
																							raise








'''simple docstring'''


def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				if b == 0:
								return 1
				if (b % 2) == 0:
								return actual_power(SCREAMING_SNAKE_CASE__				, int(b / 2	)	) * actual_power(SCREAMING_SNAKE_CASE__				, int(b / 2	)	)
				else:
								return a * actual_power(SCREAMING_SNAKE_CASE__				, int(b / 2	)	) * actual_power(SCREAMING_SNAKE_CASE__				, int(b / 2	)	)







def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				if b < 0:
								return 1 / actual_power(SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	)
				return actual_power(SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	)


if __name__ == "__main__":
				print(power(-2, -3))




