



import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
				from transformers import LlamaTokenizerFast
except ImportError as e:
				warnings.warn(e)
				warnings.warn(
				    '''The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'''
				)
				lowercase_	       =			None
lowercase_	       =			{
    '''7B''': 1_10_08,
    '''13B''': 1_38_24,
    '''30B''': 1_79_20,
    '''65B''': 2_20_16,
    '''70B''': 2_86_72,
}
lowercase_	       =			{
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}






def 					__lowerCAmelCase		(  __lowerCamelCase	:    Tuple				,   __lowerCamelCase	:    Tuple=1				,   __lowerCamelCase	:    str=256	)  ->						Any:
					return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3	)	) + multiple_of - 1) // multiple_of)






def 					__lowerCAmelCase		(  __lowerCamelCase	:    Union[str, Any]	)  ->						Optional[Any]:
					with open(__lowerCamelCase				,   """r"""	) as f:
										return json.load(__lowerCamelCase	)






def 					__lowerCAmelCase		(  __lowerCamelCase	:    List[str]				,   __lowerCamelCase	:    Optional[int]	)  ->						int:
					with open(__lowerCamelCase				,   """w"""	) as f:
										json.dump(__lowerCamelCase				,   __lowerCamelCase	)






def 					__lowerCAmelCase		(  __lowerCamelCase	:    Optional[int]				,   __lowerCamelCase	:    Optional[int]				,   __lowerCamelCase	:    int				,   __lowerCamelCase	:    List[str]=True	)  ->						Optional[Any]:
					os.makedirs(__lowerCamelCase				,   exist_ok=__lowerCamelCase	)
					__lowerCAmelCase	   =os.path.join(__lowerCamelCase				,   """tmp"""	)
					os.makedirs(__lowerCamelCase				,   exist_ok=__lowerCamelCase	)

					__lowerCAmelCase	   =read_json(os.path.join(__lowerCamelCase				,   """params.json"""	)	)
					__lowerCAmelCase	   =NUM_SHARDS[model_size]
					__lowerCAmelCase	   =params["""n_layers"""]
					__lowerCAmelCase	   =params["""n_heads"""]
					__lowerCAmelCase	   =n_heads // num_shards
					__lowerCAmelCase	   =params["""dim"""]
					__lowerCAmelCase	   =dim // n_heads
					__lowerCAmelCase	   =1_0000.0
					__lowerCAmelCase	   =1.0 / (base ** (torch.arange(0				,   __lowerCamelCase				,   2	).float() / dims_per_head))

					if "n_kv_heads" in params:
										__lowerCAmelCase	   =params["""n_kv_heads"""]  # for GQA / MQA
										__lowerCAmelCase	   =n_heads_per_shard // num_key_value_heads
										__lowerCAmelCase	   =dim // num_key_value_heads
					else:  # compatibility with other checkpoints
										__lowerCAmelCase	   =n_heads
										__lowerCAmelCase	   =n_heads_per_shard
										__lowerCAmelCase	   =dim

					# permute for sliced rotary
					def permute(__lowerCamelCase	:    Optional[int]				,   __lowerCamelCase	:    List[str]=n_heads				,   __lowerCamelCase	:    Tuple=dim				,   __lowerCamelCase	:    int=dim	):
										return w.view(__lowerCamelCase				,   dima // n_heads // 2				,   2				,   __lowerCamelCase	).transpose(1				,   2	).reshape(__lowerCamelCase				,   __lowerCamelCase	)

					print(f"""Fetching all parameters from the checkpoint at {input_base_path}."""	)
					# Load weights
					if model_size == "7B":
										# Not sharded
										# (The sharded implementation would also work, but this is simpler.)
										__lowerCAmelCase	   =torch.load(os.path.join(__lowerCamelCase				,   """consolidated.00.pth"""	)				,   map_location="""cpu"""	)
					else:
										# Sharded
										__lowerCAmelCase	   =[
										    torch.load(os.path.join(__lowerCamelCase				,   f"""consolidated.{i:02d}.pth"""	)				,   map_location="""cpu"""	)
										    for i in range(__lowerCamelCase	)
										]
					__lowerCAmelCase	   =0
					__lowerCAmelCase	   ={"""weight_map""": {}}
					for layer_i in range(__lowerCamelCase	):
										__lowerCAmelCase	   =f"""pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin"""
										if model_size == "7B":
															# Unsharded
															__lowerCAmelCase	   ={
															    f"""model.layers.{layer_i}.self_attn.q_proj.weight""": permute(
															        loaded[f"""layers.{layer_i}.attention.wq.weight"""]	),
															    f"""model.layers.{layer_i}.self_attn.k_proj.weight""": permute(
															        loaded[f"""layers.{layer_i}.attention.wk.weight"""]	),
															    f"""model.layers.{layer_i}.self_attn.v_proj.weight""": loaded[f"""layers.{layer_i}.attention.wv.weight"""],
															    f"""model.layers.{layer_i}.self_attn.o_proj.weight""": loaded[f"""layers.{layer_i}.attention.wo.weight"""],
															    f"""model.layers.{layer_i}.mlp.gate_proj.weight""": loaded[f"""layers.{layer_i}.feed_forward.w1.weight"""],
															    f"""model.layers.{layer_i}.mlp.down_proj.weight""": loaded[f"""layers.{layer_i}.feed_forward.w2.weight"""],
															    f"""model.layers.{layer_i}.mlp.up_proj.weight""": loaded[f"""layers.{layer_i}.feed_forward.w3.weight"""],
															    f"""model.layers.{layer_i}.input_layernorm.weight""": loaded[f"""layers.{layer_i}.attention_norm.weight"""],
															    f"""model.layers.{layer_i}.post_attention_layernorm.weight""": loaded[f"""layers.{layer_i}.ffn_norm.weight"""],
															}
										else:
															# Sharded
															# Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
															# the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
															# redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

															__lowerCAmelCase	   ={
															    f"""model.layers.{layer_i}.input_layernorm.weight""": loaded[0][
															        f"""layers.{layer_i}.attention_norm.weight"""
															    ].clone(),
															    f"""model.layers.{layer_i}.post_attention_layernorm.weight""": loaded[0][
															        f"""layers.{layer_i}.ffn_norm.weight"""
															    ].clone(),
															}
															__lowerCAmelCase	   =permute(
															    torch.cat(
															        [
															            loaded[i][f"""layers.{layer_i}.attention.wq.weight"""].view(__lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase	)
															            for i in range(__lowerCamelCase	)
															        ]				,   dim=0				,   ).reshape(__lowerCamelCase				,   __lowerCamelCase	)	)
															__lowerCAmelCase	   =permute(
															    torch.cat(
															        [
															            loaded[i][f"""layers.{layer_i}.attention.wk.weight"""].view(
															                __lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase	)
															            for i in range(__lowerCamelCase	)
															        ]				,   dim=0				,   ).reshape(__lowerCamelCase				,   __lowerCamelCase	)				,   __lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase				,   )
															__lowerCAmelCase	   =torch.cat(
															    [
															        loaded[i][f"""layers.{layer_i}.attention.wv.weight"""].view(
															            __lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase	)
															        for i in range(__lowerCamelCase	)
															    ]				,   dim=0				,   ).reshape(__lowerCamelCase				,   __lowerCamelCase	)

															__lowerCAmelCase	   =torch.cat(
															    [loaded[i][f"""layers.{layer_i}.attention.wo.weight"""] for i in range(__lowerCamelCase	)]				,   dim=1	)
															__lowerCAmelCase	   =torch.cat(
															    [loaded[i][f"""layers.{layer_i}.feed_forward.w1.weight"""] for i in range(__lowerCamelCase	)]				,   dim=0	)
															__lowerCAmelCase	   =torch.cat(
															    [loaded[i][f"""layers.{layer_i}.feed_forward.w2.weight"""] for i in range(__lowerCamelCase	)]				,   dim=1	)
															__lowerCAmelCase	   =torch.cat(
															    [loaded[i][f"""layers.{layer_i}.feed_forward.w3.weight"""] for i in range(__lowerCamelCase	)]				,   dim=0	)

										__lowerCAmelCase	   =inv_freq
										for k, v in state_dict.items():
															__lowerCAmelCase	   =filename
															param_count += v.numel()
										torch.save(__lowerCamelCase				,   os.path.join(__lowerCamelCase				,   __lowerCamelCase	)	)

					__lowerCAmelCase	   =f"""pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin"""
					if model_size == "7B":
										# Unsharded
										__lowerCAmelCase	   ={
										    """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
										    """model.norm.weight""": loaded["""norm.weight"""],
										    """lm_head.weight""": loaded["""output.weight"""],
										}
					else:
										__lowerCAmelCase	   ={
										    """model.norm.weight""": loaded[0]["""norm.weight"""],
										    """model.embed_tokens.weight""": torch.cat(
										        [loaded[i]["""tok_embeddings.weight"""] for i in range(__lowerCamelCase	)]				,   dim=1	),
										    """lm_head.weight""": torch.cat([loaded[i]["""output.weight"""] for i in range(__lowerCamelCase	)]				,   dim=0	),
										}

					for k, v in state_dict.items():
										__lowerCAmelCase	   =filename
										param_count += v.numel()
					torch.save(__lowerCamelCase				,   os.path.join(__lowerCamelCase				,   __lowerCamelCase	)	)

					# Write configs
					__lowerCAmelCase	   ={"""total_size""": param_count * 2}
					write_json(__lowerCamelCase				,   os.path.join(__lowerCamelCase				,   """pytorch_model.bin.index.json"""	)	)
					__lowerCAmelCase	   =params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
					__lowerCAmelCase	   =params["""multiple_of"""] if """multiple_of""" in params else 256
					__lowerCAmelCase	   =LlamaConfig(
					    hidden_size=__lowerCamelCase				,   intermediate_size=compute_intermediate_size(__lowerCamelCase				,   __lowerCamelCase				,   __lowerCamelCase	)				,   num_attention_heads=params["""n_heads"""]				,   num_hidden_layers=params["""n_layers"""]				,   rms_norm_eps=params["""norm_eps"""]				,   num_key_value_heads=__lowerCamelCase				,   )
					config.save_pretrained(__lowerCamelCase	)

					# Make space so we can load the model properly now.
					del state_dict
					del loaded
					gc.collect()

					print("""Loading the checkpoint in a Llama model."""	)
					__lowerCAmelCase	   =LlamaForCausalLM.from_pretrained(__lowerCamelCase				,   torch_dtype=torch.floataa				,   low_cpu_mem_usage=__lowerCamelCase	)
					# Avoid saving this as part of the config.
					del model.config._name_or_path

					print("""Saving in the Transformers format."""	)
					model.save_pretrained(__lowerCamelCase				,   safe_serialization=__lowerCamelCase	)
					shutil.rmtree(__lowerCamelCase	)






def 					__lowerCAmelCase		(  __lowerCamelCase	:    str				,   __lowerCamelCase	:    int	)  ->						int:
					# Initialize the tokenizer based on the `spm` model
					__lowerCAmelCase	   =LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
					print(f"""Saving a {tokenizer_class.__name__} to {tokenizer_path}."""	)
					__lowerCAmelCase	   =tokenizer_class(__lowerCamelCase	)
					tokenizer.save_pretrained(__lowerCamelCase	)






def 					__lowerCAmelCase		(  )  ->						List[Any]:
					__lowerCAmelCase	   =argparse.ArgumentParser()
					parser.add_argument(
					    """--input_dir"""				,   help="""Location of LLaMA weights, which contains tokenizer.model and model folders"""				,   )
					parser.add_argument(
					    """--model_size"""				,   choices=["""7B""", """7Bf""", """13B""", """13Bf""", """30B""", """65B""", """70B""", """70Bf""", """tokenizer_only"""]				,   )
					parser.add_argument(
					    """--output_dir"""				,   help="""Location to write HF model and tokenizer"""				,   )
					parser.add_argument("""--safe_serialization"""				,   type=__lowerCamelCase				,   help="""Whether or not to save using `safetensors`."""	)
					__lowerCAmelCase	   =parser.parse_args()
					if args.model_size != "tokenizer_only":
										write_model(
										    model_path=args.output_dir				,   input_base_path=os.path.join(args.input_dir				,   args.model_size	)				,   model_size=args.model_size				,   safe_serialization=args.safe_serialization				,   )
					__lowerCAmelCase	   =os.path.join(args.input_dir				,   """tokenizer.model"""	)
					write_tokenizer(args.output_dir				,   __lowerCamelCase	)


if __name__ == "__main__":
				main()









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


lowercase_	       =			pytest.mark.integration






@require_faiss
class 						__a (     SCREAMING_SNAKE_CASE				):



	def 		UpperCamelCase							(						self							:    Optional[int])->							List[Any]:
						__lowerCAmelCase	   =Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(snake_case_) for x in np.arange(30).tolist()]})
						return dset



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

						__lowerCAmelCase	   =self._create_dummy_dataset()
						__lowerCAmelCase	   =dset.map(
						    lambda snake_case_				,	snake_case_: {"vecs": i * np.ones(5				,	dtype=np.floataa)}				,	with_indices=snake_case_				,	keep_in_memory=snake_case_)
						__lowerCAmelCase	   =dset.add_faiss_index("""vecs"""				,	batch_size=1_00				,	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 		UpperCamelCase							(						self							:    Tuple)->							int:
						import faiss

						__lowerCAmelCase	   =self._create_dummy_dataset()
						dset.add_faiss_index_from_external_arrays(
						    external_arrays=np.ones((30, 5)) * np.arange(30).reshape(-1				,	1)				,	index_name="""vecs"""				,	batch_size=1_00				,	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 		UpperCamelCase							(						self							:    int)->							List[str]:
						import faiss

						__lowerCAmelCase	   =self._create_dummy_dataset()
						dset.add_faiss_index_from_external_arrays(
						    external_arrays=np.ones((30, 5)) * np.arange(30).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=snake_case_) 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 		UpperCamelCase							(						self							:    Any)->							Optional[int]:
						__lowerCAmelCase	   =self._create_dummy_dataset()
						dset.add_faiss_index_from_external_arrays(
						    external_arrays=np.ones((30, 5)) * np.arange(30).reshape(-1				,	1)				,	index_name="""vecs""")
						dset.drop_index("""vecs""")
						self.assertRaises(snake_case_				,	partial(dset.get_nearest_examples				,	"""vecs2"""				,	np.ones(5				,	dtype=np.floataa)))



	def 		UpperCamelCase							(						self							:    Optional[int])->							List[str]:
						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)] * 30)
											__lowerCAmelCase	   ={"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 29}]}}
											__lowerCAmelCase	   =Elasticsearch()

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






@require_faiss
class 						__a (     SCREAMING_SNAKE_CASE				):



	def 		UpperCamelCase							(						self							:    Dict)->							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				,	10)

						# single query
						__lowerCAmelCase	   =np.zeros(5				,	dtype=np.floataa)
						__lowerCAmelCase	   =1
						__lowerCAmelCase   ,	__lowerCAmelCase	   =index.search(snake_case_)
						self.assertRaises(snake_case_				,	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(snake_case_)
						self.assertRaises(snake_case_				,	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(snake_case_)				,	0)
						self.assertListEqual([4, 3, 2, 1, 0]				,	snake_case_)



	def 		UpperCamelCase							(						self							:    Optional[Any])->							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(snake_case_):
											__lowerCAmelCase	   =FaissIndex(string_factory="""Flat"""				,	custom_index=faiss.IndexFlat(5))



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

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



	def 		UpperCamelCase							(						self							:    str)->							Union[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=snake_case_) 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(snake_case_)
						self.assertGreater(scores[0]				,	0)
						self.assertEqual(indices[0]				,	1)






@require_faiss
def 					__lowerCAmelCase		(  __lowerCamelCase	:    Optional[Any]	)  ->						List[str]:
					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 						__a (     SCREAMING_SNAKE_CASE				):



	def 		UpperCamelCase							(						self							:    List[str])->							Optional[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=snake_case_)
											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(snake_case_)
											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(snake_case_				,	request_timeout=30)
											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(snake_case_)
											__lowerCAmelCase	   =[scores[0] for scores in total_scores]
											__lowerCAmelCase	   =[indices[0] for indices in total_indices]
											self.assertGreater(np.min(snake_case_)				,	0)
											self.assertListEqual([1, 1, 1]				,	snake_case_)

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




