code: 
  '''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_     			=       """block_records.npy"""
  
  
  UpperCamelCase_     			=       logging.get_logger(__name__)
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       str  ,      _lowerCamelCase						:       int		)    ->						np.ndarray:
    import tensorflow.compat.va as tf
  
    _lowerCAmelCase       :  Optional[Any]   				=					tf.data.TFRecordDataset(_lowerCamelCase  ,      buffer_size=5_12 * 10_24 * 10_24		)
    _lowerCAmelCase       :  int   				=					blocks_dataset.batch(_lowerCamelCase  ,      drop_remainder=_lowerCamelCase		)
    _lowerCAmelCase       :  Optional[Any]   				=					next(blocks_dataset.take(1		).as_numpy_iterator()		)
  
    return np_record
  
  
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_   ,   snake_case_   ,   snake_case_=2   ,   snake_case_=1_0_0_0   ,   snake_case_=1_0_0   ,   snake_case_=1_0_0_0_0_0   ,   ):
           from scann.scann_ops.py.scann_ops_pybind import builder as Builder
  
           _lowerCAmelCase       :  List[str]   				=					Builder(db=snake_case_   ,   num_neighbors=snake_case_   ,   distance_measure="""dot_product"""  )
           _lowerCAmelCase       :  List[Any]   				=					builder.tree(
               num_leaves=snake_case_   ,   num_leaves_to_search=snake_case_   ,   training_sample_size=snake_case_  )
           _lowerCAmelCase       :  List[Any]   				=					builder.score_ah(dimensions_per_block=snake_case_  )
  
           _lowerCAmelCase       :  Optional[int]   				=					builder.build()
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           _lowerCAmelCase				,					_lowerCAmelCase       :  List[str]   				=					self.searcher.search_batched(question_projection.detach().cpu()  )
           return retrieved_block_ids.astype("""int64"""  )
  
  
  
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_   ,   snake_case_  ):
           super().__init__()
           _lowerCAmelCase       :  Optional[Any]   				=					block_records
           _lowerCAmelCase       :  Optional[Any]   				=					tokenizer
  
  
  
  
         def __call__(     self   ,   snake_case_   ,   snake_case_   ,   snake_case_   ,   snake_case_=None   ,   snake_case_="pt"  ):
           _lowerCAmelCase       :  Optional[Any]   				=					np.take(self.block_records   ,   indices=snake_case_   ,   axis=0  )
  
           _lowerCAmelCase       :  Optional[Any]   				=					self.tokenizer.decode(question_input_ids[0]   ,   skip_special_tokens=snake_case_  )
  
           _lowerCAmelCase       :  Union[str, Any]   				=					[]
           _lowerCAmelCase       :  Any   				=					[]
           for retrieved_block in retrieved_blocks:
             text.append(snake_case_  )
             text_pair.append(retrieved_block.decode()  )
  
           _lowerCAmelCase       :  Any   				=					self.tokenizer(
               snake_case_   ,   snake_case_   ,   padding=snake_case_   ,   truncation=snake_case_   ,   return_special_tokens_mask=snake_case_   ,   max_length=snake_case_  )
           _lowerCAmelCase       :  Dict   				=					concat_inputs.convert_to_tensors(snake_case_  )
  
           if answer_ids is not None:
             return self.block_has_answer(snake_case_   ,   snake_case_  ) + (concat_inputs_tensors,)
           else:
             return (None, None, None, concat_inputs_tensors)
  
  
  
  
         @classmethod
         def 							__UpperCamelCase       (     cls   ,   snake_case_   ,   *snake_case_   ,   **snake_case_  ):
           if os.path.isdir(snake_case_  ):
             _lowerCAmelCase       :  Tuple   				=					os.path.join(snake_case_   ,   _REALM_BLOCK_RECORDS_FILENAME  )
           else:
             _lowerCAmelCase       :  Union[str, Any]   				=					hf_hub_download(
                 repo_id=snake_case_   ,   filename=_REALM_BLOCK_RECORDS_FILENAME   ,   **snake_case_  )
           _lowerCAmelCase       :  Optional[int]   				=					np.load(snake_case_   ,   allow_pickle=snake_case_  )
  
           _lowerCAmelCase       :  List[Any]   				=					AutoTokenizer.from_pretrained(snake_case_   ,   *snake_case_   ,   **snake_case_  )
  
           return cls(snake_case_   ,   snake_case_  )
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           # save block records
           np.save(os.path.join(snake_case_   ,   _REALM_BLOCK_RECORDS_FILENAME  )   ,   self.block_records  )
           # save tokenizer
           self.tokenizer.save_pretrained(snake_case_  )
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_   ,   snake_case_  ):
           _lowerCAmelCase       :  List[str]   				=					[]
           _lowerCAmelCase       :  Optional[Any]   				=					[]
           _lowerCAmelCase       :  List[str]   				=					[]
           _lowerCAmelCase       :  Optional[int]   				=					0
  
           for input_id in concat_inputs.input_ids:
             _lowerCAmelCase       :  List[Any]   				=					input_id.tolist()
             # Check answers between two [SEP] tokens
             _lowerCAmelCase       :  int   				=					input_id_list.index(self.tokenizer.sep_token_id  )
             _lowerCAmelCase       :  Optional[int]   				=					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   ,   snake_case_  ):
                 if answer[0] == input_id_list[idx]:
                   if input_id_list[idx : idx + len(snake_case_  )] == answer:
                     start_pos[-1].append(snake_case_  )
                     end_pos[-1].append(idx + len(snake_case_  ) - 1  )
  
             if len(start_pos[-1]  ) == 0:
               has_answers.append(snake_case_  )
             else:
               has_answers.append(snake_case_  )
               if len(start_pos[-1]  ) > max_answers:
                 _lowerCAmelCase       :  int   				=					len(start_pos[-1]  )
  
          # Pad -1 to max_answers
           for start_pos_, end_pos_ in zip(snake_case_   ,   snake_case_  ):
             if len(start_pos_  ) < max_answers:
               _lowerCAmelCase       :  Union[str, Any]   				=					[-1] * (max_answers - len(start_pos_  ))
               start_pos_ += padded
               end_pos_ += padded
           return has_answers, start_pos, end_pos
  
  
  
style_context: 
  '''simple docstring'''
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int		)    ->						float:
    if common_ratio == 1:
      # Formula for sum if common ratio is 1
      return num_of_terms * first_term
  
    # Formula for finding sum of n terms of a GeometricProgression
    return (first_term / (1 - common_ratio)) * (1 - common_ratio**num_of_terms)
  
  
  