





import os
import re
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__A									=				logging.get_logger(__name__)

__A									=				{"vocab_file": "spiece.model"}

__A									=				{
    "vocab_file": {
        "google/bigbird-roberta-base": "https://huggingface.co/google/bigbird-roberta-base/resolve/main/spiece.model",
        "google/bigbird-roberta-large": (
            "https://huggingface.co/google/bigbird-roberta-large/resolve/main/spiece.model"
        ),
        "google/bigbird-base-trivia-itc": (
            "https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/spiece.model"
        ),
    }
}

__A									=				{
    "google/bigbird-roberta-base": 4096,
    "google/bigbird-roberta-large": 4096,
    "google/bigbird-base-trivia-itc": 4096,
}



class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''
 lowercase_		=			VOCAB_FILES_NAMES
 lowercase_		=			PRETRAINED_VOCAB_FILES_MAP
 lowercase_		=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase_		=			["input_ids", "attention_mask"]
 lowercase_		=			[]

 def __init__(self				:   Tuple       , UpperCAmelCase_				:   Dict       , UpperCAmelCase_				:   List[str]="<unk>"       , UpperCAmelCase_				:   Union[str, Any]="<s>"       , UpperCAmelCase_				:   int="</s>"       , UpperCAmelCase_				:   List[str]="<pad>"       , UpperCAmelCase_				:   str="[SEP]"       , UpperCAmelCase_				:   List[str]="[MASK]"       , UpperCAmelCase_				:   Dict="[CLS]"       , UpperCAmelCase_				:   Optional[Dict[str, Any]] = None       , **UpperCAmelCase_				:   int       , )       ->None:



   '''simple docstring'''



   lowerCamelCase__:      Tuple			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else bos_token
   lowerCamelCase__:      int			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else eos_token
   lowerCamelCase__:      Any			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else unk_token
   lowerCamelCase__:      Union[str, Any]			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else pad_token
   lowerCamelCase__:      Any			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else cls_token
   lowerCamelCase__:      Any			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else sep_token

   # Mask token behave like a normal word, i.e. include the space before it
   lowerCamelCase__:      Optional[int]			  =AddedToken(UpperCAmelCase_       , lstrip=UpperCAmelCase_       , rstrip=UpperCAmelCase_) if isinstance(UpperCAmelCase_       , UpperCAmelCase_) else mask_token

   lowerCamelCase__:      Optional[int]			  ={} if sp_model_kwargs is None else sp_model_kwargs

   super().__init__(
       bos_token=UpperCAmelCase_       , eos_token=UpperCAmelCase_       , unk_token=UpperCAmelCase_       , pad_token=UpperCAmelCase_       , sep_token=UpperCAmelCase_       , mask_token=UpperCAmelCase_       , cls_token=UpperCAmelCase_       , sp_model_kwargs=self.sp_model_kwargs       , **UpperCAmelCase_       , )

   lowerCamelCase__:      Union[str, Any]			  =vocab_file

   lowerCamelCase__:      Optional[Any]			  =spm.SentencePieceProcessor(**self.sp_model_kwargs)
   self.sp_model.Load(UpperCAmelCase_)

 @property
 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any])       ->str:



   '''simple docstring'''



   return self.sp_model.get_piece_size()

 def 							SCREAMING_SNAKE_CASE_					(self				:   Any)       ->Tuple:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  ={self.convert_ids_to_tokens(UpperCAmelCase_): i for i in range(self.vocab_size)}
   vocab.update(self.added_tokens_encoder)
   return vocab

 def __getstate__(self				:   Union[str, Any])       ->str:



   '''simple docstring'''



   lowerCamelCase__:      int			  =self.__dict__.copy()
   lowerCamelCase__:      Any			  =None
   return state

 def __setstate__(self				:   Dict       , UpperCAmelCase_				:   Any)       ->int:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =d

   # for backward compatibility
   if not hasattr(self       , "sp_model_kwargs"):
     lowerCamelCase__:      str			  ={}

   lowerCamelCase__:      Optional[Any]			  =spm.SentencePieceProcessor(**self.sp_model_kwargs)
   self.sp_model.Load(self.vocab_file)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any]       , UpperCAmelCase_				:   str)       ->List[str]:



   '''simple docstring'''



   return self.sp_model.encode(UpperCAmelCase_       , out_type=UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Dict       , UpperCAmelCase_				:   Optional[Any])       ->Dict:



   '''simple docstring'''



   return self.sp_model.piece_to_id(UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any]       , UpperCAmelCase_				:   List[str])       ->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__:      Tuple			  =self.sp_model.IdToPiece(UpperCAmelCase_)
   return token

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , UpperCAmelCase_				:   Dict)       ->str:



   '''simple docstring'''



   lowerCamelCase__:      List[Any]			  =[]
   lowerCamelCase__:      Any			  =""
   lowerCamelCase__:      Any			  =False
   for token in tokens:
     # make sure that special tokens are not decoded using sentencepiece model
     if token in self.all_special_tokens:
       if not prev_is_special:
         out_string += " "
       out_string += self.sp_model.decode(UpperCAmelCase_) + token
       lowerCamelCase__:      str			  =True
       lowerCamelCase__:      List[str]			  =[]
     else:
       current_sub_tokens.append(UpperCAmelCase_)
       lowerCamelCase__:      Optional[Any]			  =False
   out_string += self.sp_model.decode(UpperCAmelCase_)
   return out_string.strip()

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any]       , UpperCAmelCase_				:   List[int]       , UpperCAmelCase_				:   bool = False       , UpperCAmelCase_				:   bool = None       , UpperCAmelCase_				:   bool = True       , **UpperCAmelCase_				:   Any       , )       ->str:



   '''simple docstring'''



   lowerCamelCase__:      str			  =kwargs.pop("use_source_tokenizer"       , UpperCAmelCase_)

   lowerCamelCase__:      List[str]			  =self.convert_ids_to_tokens(UpperCAmelCase_       , skip_special_tokens=UpperCAmelCase_)

   # To avoid mixing byte-level and unicode for byte-level BPT
   # we need to build string separately for added tokens and byte-level tokens
   # cf. https://github.com/huggingface/transformers/issues/1133
   lowerCamelCase__:      Union[str, Any]			  =[]
   lowerCamelCase__:      List[Any]			  =[]
   for token in filtered_tokens:
     if skip_special_tokens and token in self.all_special_ids:
       continue
     if token in self.added_tokens_encoder:
       if current_sub_text:
         sub_texts.append(self.convert_tokens_to_string(UpperCAmelCase_))
         lowerCamelCase__:      Tuple			  =[]
       sub_texts.append(UpperCAmelCase_)
     else:
       current_sub_text.append(UpperCAmelCase_)
   if current_sub_text:
     sub_texts.append(self.convert_tokens_to_string(UpperCAmelCase_))

   # Mimic the behavior of the Rust tokenizer:
   # No space before [MASK] and [SEP]
   if spaces_between_special_tokens:
     lowerCamelCase__:      int			  =re.sub(R" (\[(MASK|SEP)\])"       , R"\1"       , " ".join(UpperCAmelCase_))
   else:
     lowerCamelCase__:      Any			  ="".join(UpperCAmelCase_)

   lowerCamelCase__:      Dict			  =(
       clean_up_tokenization_spaces
       if clean_up_tokenization_spaces is not None
       else self.clean_up_tokenization_spaces
   )
   if clean_up_tokenization_spaces:
     lowerCamelCase__:      int			  =self.clean_up_tokenization(UpperCAmelCase_)
     return clean_text
   else:
     return text

 def 							SCREAMING_SNAKE_CASE_					(self				:   Any       , UpperCAmelCase_				:   str       , UpperCAmelCase_				:   Optional[str] = None)       ->Tuple[str]:



   '''simple docstring'''



   if not os.path.isdir(UpperCAmelCase_):
     logger.error(F"""Vocabulary path ({save_directory}) should be a directory""")
     return
   lowerCamelCase__:      int			  =os.path.join(
       UpperCAmelCase_       , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"])

   if os.path.abspath(self.vocab_file) != os.path.abspath(UpperCAmelCase_) and os.path.isfile(self.vocab_file):
     copyfile(self.vocab_file       , UpperCAmelCase_)
   elif not os.path.isfile(self.vocab_file):
     with open(UpperCAmelCase_       , "wb") as fi:
       lowerCamelCase__:      Any			  =self.sp_model.serialized_model_proto()
       fi.write(UpperCAmelCase_)

   return (out_vocab_file,)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Dict       , UpperCAmelCase_				:   List[int]       , UpperCAmelCase_				:   Optional[List[int]] = None)       ->List[int]:



   '''simple docstring'''



   if token_ids_a is None:
     return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
   lowerCamelCase__:      List[Any]			  =[self.cls_token_id]
   lowerCamelCase__:      List[str]			  =[self.sep_token_id]
   return cls + token_ids_a + sep + token_ids_a + sep

 def 							SCREAMING_SNAKE_CASE_					(self				:   int       , UpperCAmelCase_				:   List[int]       , UpperCAmelCase_				:   Optional[List[int]] = None       , UpperCAmelCase_				:   bool = False)       ->List[int]:



   '''simple docstring'''



   if already_has_special_tokens:
     return super().get_special_tokens_mask(
         token_ids_a=UpperCAmelCase_       , token_ids_a=UpperCAmelCase_       , already_has_special_tokens=UpperCAmelCase_)

   if token_ids_a is None:
     return [1] + ([0] * len(UpperCAmelCase_)) + [1]
   return [1] + ([0] * len(UpperCAmelCase_)) + [1] + ([0] * len(UpperCAmelCase_)) + [1]







 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any]       , UpperCAmelCase_				:   List[int]       , UpperCAmelCase_				:   Optional[List[int]] = None)       ->List[int]:



   '''simple docstring'''



   lowerCamelCase__:      str			  =[self.sep_token_id]
   lowerCamelCase__:      Optional[int]			  =[self.cls_token_id]
   if token_ids_a is None:
     return len(cls + token_ids_a + sep) * [0]
   return len(cls + token_ids_a + sep) * [0] + len(token_ids_a + sep) * [1]








import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


_snake_case  :    Dict						    =  pytest.mark.integration



@require_faiss
class 				_UpperCAmelCase    (    _UpperCamelCase    ):

  """simple docstring"""


  def 				lowercase		(				self :		List[Any]     )							->						Optional[Any]:
     __lowerCAmelCase								=	Dataset.from_dict({'filename': ['my_name-train' + '_' + str(lowerCAmelCase_     ) for x in np.arange(3_0     ).tolist()]}     )
     return dset






  def 				lowercase		(				self :		List[str]     )							->						Tuple:
     import faiss

     __lowerCAmelCase								=	self._create_dummy_dataset()
     __lowerCAmelCase								=	dset.map(
         lambda lowerCAmelCase_					,  lowerCAmelCase_     : {"vecs": i * np.ones(5					,  dtype=np.floataa     )}					,  with_indices=lowerCAmelCase_					,  keep_in_memory=lowerCAmelCase_     )
     __lowerCAmelCase								=	dset.add_faiss_index('vecs'					,  batch_size=1_0_0					,  metric_type=faiss.METRIC_INNER_PRODUCT     )
     __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('vecs'					,  np.ones(5					,  dtype=np.floataa     )     )
     self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )
     dset.drop_index('vecs'     )






  def 				lowercase		(				self :		Optional[Any]     )							->						str:
     import faiss

     __lowerCAmelCase								=	self._create_dummy_dataset()
     dset.add_faiss_index_from_external_arrays(
         external_arrays=np.ones((3_0, 5)     ) * np.arange(3_0     ).reshape(-1					,  1     )					,  index_name='vecs'					,  batch_size=1_0_0					,  metric_type=faiss.METRIC_INNER_PRODUCT					,  )
     __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('vecs'					,  np.ones(5					,  dtype=np.floataa     )     )
     self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )






  def 				lowercase		(				self :		int     )							->						Optional[Any]:
     import faiss

     __lowerCAmelCase								=	self._create_dummy_dataset()
     dset.add_faiss_index_from_external_arrays(
         external_arrays=np.ones((3_0, 5)     ) * np.arange(3_0     ).reshape(-1					,  1     )					,  index_name='vecs'					,  metric_type=faiss.METRIC_INNER_PRODUCT					,  )

     # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
     # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
     # see https://bugs.python.org/issue14243 and
     # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
     with tempfile.NamedTemporaryFile(delete=lowerCAmelCase_     ) as tmp_file:
        dset.save_faiss_index('vecs'					,  tmp_file.name     )
        dset.load_faiss_index('vecs2'					,  tmp_file.name     )
     os.unlink(tmp_file.name     )

     __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('vecs2'					,  np.ones(5					,  dtype=np.floataa     )     )
     self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )






  def 				lowercase		(				self :		Union[str, Any]     )							->						List[Any]:
     __lowerCAmelCase								=	self._create_dummy_dataset()
     dset.add_faiss_index_from_external_arrays(
         external_arrays=np.ones((3_0, 5)     ) * np.arange(3_0     ).reshape(-1					,  1     )					,  index_name='vecs'     )
     dset.drop_index('vecs'     )
     self.assertRaises(lowerCAmelCase_					,  partial(dset.get_nearest_examples					,  'vecs2'					,  np.ones(5					,  dtype=np.floataa     )     )     )






  def 				lowercase		(				self :		Union[str, Any]     )							->						Tuple:
     from elasticsearch import Elasticsearch

     __lowerCAmelCase								=	self._create_dummy_dataset()
     with patch('elasticsearch.Elasticsearch.search'     ) as mocked_search, patch(
         'elasticsearch.client.IndicesClient.create'     ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk'     ) as mocked_bulk:
        __lowerCAmelCase								=	{'acknowledged': True}
        mocked_bulk.return_value([(True, None)] * 3_0     )
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 2_9}]}}
        __lowerCAmelCase								=	Elasticsearch()

        dset.add_elasticsearch_index('filename'					,  es_client=lowerCAmelCase_     )
        __lowerCAmelCase	,	__lowerCAmelCase								=	dset.get_nearest_examples('filename'					,  'my_name-train_29'     )
        self.assertEqual(examples['filename'][0]					,  'my_name-train_29'     )





@require_faiss
class 				_UpperCAmelCase    (    _UpperCamelCase    ):

  """simple docstring"""


  def 				lowercase		(				self :		str     )							->						int:
     import faiss

     __lowerCAmelCase								=	FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT     )

     # add vectors
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsNotNone(index.faiss_index     )
     self.assertEqual(index.faiss_index.ntotal					,  5     )
     index.add_vectors(np.zeros((5, 5)					,  dtype=np.floataa     )     )
     self.assertEqual(index.faiss_index.ntotal					,  1_0     )

     # single query
     __lowerCAmelCase								=	np.zeros(5					,  dtype=np.floataa     )
     __lowerCAmelCase								=	1
     __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_     )
     self.assertRaises(lowerCAmelCase_					,  index.search					,  query.reshape(-1					,  1     )     )
     self.assertGreater(scores[0]					,  0     )
     self.assertEqual(indices[0]					,  1     )

     # batched queries
     __lowerCAmelCase								=	np.eye(5					,  dtype=np.floataa     )[::-1]
     __lowerCAmelCase	,	__lowerCAmelCase								=	index.search_batch(lowerCAmelCase_     )
     self.assertRaises(lowerCAmelCase_					,  index.search_batch					,  queries[0]     )
     __lowerCAmelCase								=	[scores[0] for scores in total_scores]
     __lowerCAmelCase								=	[indices[0] for indices in total_indices]
     self.assertGreater(np.min(lowerCAmelCase_     )					,  0     )
     self.assertListEqual([4, 3, 2, 1, 0]					,  lowerCAmelCase_     )






  def 				lowercase		(				self :		List[Any]     )							->						List[str]:
     import faiss

     __lowerCAmelCase								=	FaissIndex(string_factory='Flat'     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsInstance(index.faiss_index					,  faiss.IndexFlat     )
     __lowerCAmelCase								=	FaissIndex(string_factory='LSH'     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsInstance(index.faiss_index					,  faiss.IndexLSH     )
     with self.assertRaises(lowerCAmelCase_     ):
        __lowerCAmelCase								=	FaissIndex(string_factory='Flat'					,  custom_index=faiss.IndexFlat(5     )     )






  def 				lowercase		(				self :		Union[str, Any]     )							->						Dict:
     import faiss

     __lowerCAmelCase								=	faiss.IndexFlat(5     )
     __lowerCAmelCase								=	FaissIndex(custom_index=lowerCAmelCase_     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )
     self.assertIsInstance(index.faiss_index					,  faiss.IndexFlat     )






  def 				lowercase		(				self :		str     )							->						Any:
     import faiss

     __lowerCAmelCase								=	FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT     )
     index.add_vectors(np.eye(5					,  dtype=np.floataa     )     )

     # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
     # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
     # see https://bugs.python.org/issue14243 and
     # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
     with tempfile.NamedTemporaryFile(delete=lowerCAmelCase_     ) as tmp_file:
        index.save(tmp_file.name     )
        __lowerCAmelCase								=	FaissIndex.load(tmp_file.name     )
     os.unlink(tmp_file.name     )

     __lowerCAmelCase								=	np.zeros(5					,  dtype=np.floataa     )
     __lowerCAmelCase								=	1
     __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_     )
     self.assertGreater(scores[0]					,  0     )
     self.assertEqual(indices[0]					,  1     )





@require_faiss
def   a_    ( lowerCAmelCase_      :			Union[str, Any]	):
   import faiss

   __lowerCAmelCase								=	FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT	)
   index.add_vectors(np.eye(5,	dtype=np.floataa	)	)

   __lowerCAmelCase								=	'index.faiss'
   __lowerCAmelCase								=	F"""mock://{index_name}"""
   index.save(lowerCAmelCase_,	storage_options=mockfs.storage_options	)
   __lowerCAmelCase								=	FaissIndex.load(lowerCAmelCase_,	storage_options=mockfs.storage_options	)

   __lowerCAmelCase								=	np.zeros(5,	dtype=np.floataa	)
   __lowerCAmelCase								=	1
   __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_	)
   assert scores[0] > 0
   assert indices[0] == 1




@require_elasticsearch
class 				_UpperCAmelCase    (    _UpperCamelCase    ):

  """simple docstring"""


  def 				lowercase		(				self :		Any     )							->						int:
     from elasticsearch import Elasticsearch

     with patch('elasticsearch.Elasticsearch.search'     ) as mocked_search, patch(
         'elasticsearch.client.IndicesClient.create'     ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk'     ) as mocked_bulk:
        __lowerCAmelCase								=	Elasticsearch()
        __lowerCAmelCase								=	{'acknowledged': True}
        __lowerCAmelCase								=	ElasticSearchIndex(es_client=lowerCAmelCase_     )
        mocked_bulk.return_value([(True, None)] * 3     )
        index.add_documents(['foo', 'bar', 'foobar']     )

        # single query
        __lowerCAmelCase								=	'foo'
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 0}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_     )
        self.assertEqual(scores[0]					,  1     )
        self.assertEqual(indices[0]					,  0     )

        # single query with timeout
        __lowerCAmelCase								=	'foo'
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 0}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search(lowerCAmelCase_					,  request_timeout=3_0     )
        self.assertEqual(scores[0]					,  1     )
        self.assertEqual(indices[0]					,  0     )

        # batched queries
        __lowerCAmelCase								=	['foo', 'bar', 'foobar']
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 1}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search_batch(lowerCAmelCase_     )
        __lowerCAmelCase								=	[scores[0] for scores in total_scores]
        __lowerCAmelCase								=	[indices[0] for indices in total_indices]
        self.assertGreater(np.min(lowerCAmelCase_     )					,  0     )
        self.assertListEqual([1, 1, 1]					,  lowerCAmelCase_     )

        # batched queries with timeout
        __lowerCAmelCase								=	['foo', 'bar', 'foobar']
        __lowerCAmelCase								=	{'hits': {'hits': [{'_score': 1, '_id': 1}]}}
        __lowerCAmelCase	,	__lowerCAmelCase								=	index.search_batch(lowerCAmelCase_					,  request_timeout=3_0     )
        __lowerCAmelCase								=	[scores[0] for scores in total_scores]
        __lowerCAmelCase								=	[indices[0] for indices in total_indices]
        self.assertGreater(np.min(lowerCAmelCase_     )					,  0     )
        self.assertListEqual([1, 1, 1]					,  lowerCAmelCase_     )

