



"""simple docstring"""






import os
from typing import Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ... import AutoTokenizer
from ...utils import logging


__UpperCAmelCase      :      List[str]   					=					'block_records.npy'


__UpperCAmelCase      :      Dict   					=					logging.get_logger(__name__)
def      A      (			_A,     _A							):




					"""simple docstring"""
					import tensorflow.compat.va as tf

					snake_case_						:Union[str, Any]								=						tf.data.TFRecordDataset(_A,     buffer_size=512 * 1_024 * 1_024							)
					snake_case_						:List[str]								=						blocks_dataset.batch(_A,     drop_remainder=_A							)
					snake_case_						:str								=						next(blocks_dataset.take(1							).as_numpy_iterator()							)

					return np_record

class 	__lowerCAmelCase							:


					'''simple docstring'''


					def __init__(      self    ,       a    ,       a    ,       a=2    ,       a=10_00    ,       a=1_00    ,       a=10_00_00    ,       ):




										"""simple docstring"""





										from scann.scann_ops.py.scann_ops_pybind import builder as Builder

										snake_case_						:Any								=						Builder(db=a    ,       num_neighbors=a    ,       distance_measure="dot_product"   )
										snake_case_						:List[Any]								=						builder.tree(
										    num_leaves=a    ,       num_leaves_to_search=a    ,       training_sample_size=a   )
										snake_case_						:Union[str, Any]								=						builder.score_ah(dimensions_per_block=a   )

										snake_case_						:Optional[int]								=						builder.build()







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										snake_case_	,  snake_case_						:int								=						self.searcher.search_batched(question_projection.detach().cpu()   )
										return retrieved_block_ids.astype("int64"   )



class 	__lowerCAmelCase							:


					'''simple docstring'''


					def __init__(      self    ,       a    ,       a   ):




										"""simple docstring"""





										super().__init__()
										snake_case_						:str								=						block_records
										snake_case_						:int								=						tokenizer







					def __call__(      self    ,       a    ,       a    ,       a    ,       a=None    ,       a="pt"   ):




										"""simple docstring"""





										snake_case_						:Optional[Any]								=						np.take(self.block_records    ,       indices=a    ,       axis=0   )

										snake_case_						:Union[str, Any]								=						self.tokenizer.decode(question_input_ids[0]    ,       skip_special_tokens=a   )

										snake_case_						:Tuple								=						[]
										snake_case_						:Optional[Any]								=						[]
										for retrieved_block in retrieved_blocks:
															text.append(a   )
															text_pair.append(retrieved_block.decode()   )

										snake_case_						:Union[str, Any]								=						self.tokenizer(
										    a    ,       a    ,       padding=a    ,       truncation=a    ,       return_special_tokens_mask=a    ,       max_length=a   )
										snake_case_						:Tuple								=						concat_inputs.convert_to_tensors(a   )

										if answer_ids is not None:
															return self.block_has_answer(a    ,       a   ) + (concat_inputs_tensors,)
										else:
															return (None, None, None, concat_inputs_tensors)







					@classmethod
					def 		_a (      cls    ,       a    ,       *a    ,       **a   ):




										"""simple docstring"""





										if os.path.isdir(a   ):
															snake_case_						:str								=						os.path.join(a    ,       _REALM_BLOCK_RECORDS_FILENAME   )
										else:
															snake_case_						:List[str]								=						hf_hub_download(
															    repo_id=a    ,       filename=_REALM_BLOCK_RECORDS_FILENAME    ,       **a   )
										snake_case_						:str								=						np.load(a    ,       allow_pickle=a   )

										snake_case_						:Any								=						AutoTokenizer.from_pretrained(a    ,       *a    ,       **a   )

										return cls(a    ,       a   )







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										np.save(os.path.join(a    ,       _REALM_BLOCK_RECORDS_FILENAME   )    ,       self.block_records   )
										# save tokenizer
										self.tokenizer.save_pretrained(a   )







					def 		_a (      self    ,       a    ,       a   ):




										"""simple docstring"""





										snake_case_						:Any								=						[]
										snake_case_						:Optional[int]								=						[]
										snake_case_						:Optional[Any]								=						[]
										snake_case_						:Tuple								=						0

										for input_id in concat_inputs.input_ids:
															snake_case_						:Dict								=						input_id.tolist()
															# Check answers between two [SEP] tokens
															snake_case_						:Optional[int]								=						input_id_list.index(self.tokenizer.sep_token_id   )
															snake_case_						:Any								=						first_sep_idx + 1 + input_id_list[first_sep_idx + 1 :].index(self.tokenizer.sep_token_id   )

															start_pos.append([]   )
															end_pos.append([]   )
															for answer in answer_ids:
																				for idx in range(first_sep_idx + 1    ,       a   ):
																									if answer[0] == input_id_list[idx]:
																														if input_id_list[idx : idx + len(a   )] == answer:
																																			start_pos[-1].append(a   )
																																			end_pos[-1].append(idx + len(a   ) - 1   )

															if len(start_pos[-1]   ) == 0:
																				has_answers.append(a   )
															else:
																				has_answers.append(a   )
																				if len(start_pos[-1]   ) > max_answers:
																									snake_case_						:List[str]								=						len(start_pos[-1]   )

        # Pad -1 to max_answers
										for start_pos_, end_pos_ in zip(a    ,       a   ):
															if len(start_pos_   ) < max_answers:
																				snake_case_						:Dict								=						[-1] * (max_answers - len(start_pos_   ))
																				start_pos_ += padded
																				end_pos_ += padded
										return has_answers, start_pos, end_pos






"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if n == 0:
										return 1

					elif n % 2 == 1:
										return binary_exponentiation(_A,     n - 1							) * a

					else:
										snake_case_						:Optional[int]								=						binary_exponentiation(_A,     n / 2							)
										return b * b


if __name__ == "__main__":
				try:
								__UpperCAmelCase      :      str   					=					int(input('Enter Base : ').strip())
								__UpperCAmelCase      :      Any   					=					int(input('Enter Power : ').strip())
				except ValueError:
								print('Invalid literal for integer')

				__UpperCAmelCase      :      Optional[int]   					=					binary_exponentiation(BASE, POWER)
				print(F'''{BASE}^({POWER}) : {RESULT}''')

