



"""simple docstring"""




import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConformerConfig,
    WavaVecaConformerForCTC,
    WavaVecaConformerForPreTraining,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
lowerCAmelCase							:    str  							=							logging.get_logger(__name__)

lowerCAmelCase							:    str  							=							{
    """post_extract_proj""": """feature_projection.projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """self_attn.linear_k""": """encoder.layers.*.self_attn.linear_k""",
    """self_attn.linear_v""": """encoder.layers.*.self_attn.linear_v""",
    """self_attn.linear_q""": """encoder.layers.*.self_attn.linear_q""",
    """self_attn.pos_bias_u""": """encoder.layers.*.self_attn.pos_bias_u""",
    """self_attn.pos_bias_v""": """encoder.layers.*.self_attn.pos_bias_v""",
    """self_attn.linear_out""": """encoder.layers.*.self_attn.linear_out""",
    """self_attn.linear_pos""": """encoder.layers.*.self_attn.linear_pos""",
    """self_attn.rotary_emb""": """encoder.embed_positions""",
    """self_attn_layer_norm""": """encoder.layers.*.self_attn_layer_norm""",
    """conv_module.pointwise_conv1""": """encoder.layers.*.conv_module.pointwise_conv1""",
    """conv_module.pointwise_conv2""": """encoder.layers.*.conv_module.pointwise_conv2""",
    """conv_module.depthwise_conv""": """encoder.layers.*.conv_module.depthwise_conv""",
    """conv_module.batch_norm""": """encoder.layers.*.conv_module.batch_norm""",
    """conv_module.layer_norm""": """encoder.layers.*.conv_module.layer_norm""",
    """ffn1.w_1""": """encoder.layers.*.ffn1.intermediate_dense""",
    """ffn1.w_2""": """encoder.layers.*.ffn1.output_dense""",
    """ffn1.layer_norm""": """encoder.layers.*.ffn1_layer_norm""",
    """ffn2.w_1""": """encoder.layers.*.ffn2.intermediate_dense""",
    """ffn2.w_2""": """encoder.layers.*.ffn2.output_dense""",
    """ffn2.layer_norm""": """encoder.layers.*.ffn2_layer_norm""",
    """final_layer_norm""": """encoder.layers.*.final_layer_norm""",
    """encoder.layer_norm""": """encoder.layer_norm""",
    """w2v_model.layer_norm""": """feature_projection.layer_norm""",
    """quantizer.weight_proj""": """quantizer.weight_proj""",
    """quantizer.vars""": """quantizer.codevectors""",
    """project_q""": """project_q""",
    """final_proj""": """project_hid""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
}
lowerCAmelCase							:    Tuple  							=							[
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
]



def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__       )		->      Optional[Any]:
			for attribute in key.split("""."""       ):
						lowerCamelCase       =      getattr(snake_case__ ,				snake_case__       )

			if weight_type is not None:
						lowerCamelCase       =      getattr(snake_case__ ,				snake_case__       ).shape
			else:
						lowerCamelCase       =      hf_pointer.shape

			if hf_shape != value.shape:
						raise ValueError(
						    F'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
						    F' {value.shape} for {full_name}'       )

			if weight_type == "weight":
						lowerCamelCase       =      value
			elif weight_type == "weight_g":
						lowerCamelCase       =      value
			elif weight_type == "weight_v":
						lowerCamelCase       =      value
			elif weight_type == "bias":
						lowerCamelCase       =      value
			elif weight_type == "running_mean":
						lowerCamelCase       =      value
			elif weight_type == "running_var":
						lowerCamelCase       =      value
			elif weight_type == "num_batches_tracked":
						lowerCamelCase       =      value
			elif weight_type == "inv_freq":
						lowerCamelCase       =      value
			else:
						lowerCamelCase       =      value

			logger.info(F'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'       )



def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__       )		->      Union[str, Any]:
			lowerCamelCase       =      []
			lowerCamelCase       =      fairseq_model.state_dict()

			lowerCamelCase       =      hf_model.wavaveca_conformer.feature_extractor

			for name, value in fairseq_dict.items():
						lowerCamelCase       =      False
						if "conv_layers" in name:
									load_conv_layer(
									    snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				hf_model.config.feat_extract_norm == """group""" ,				)
									lowerCamelCase       =      True
						else:
									for key, mapped_key in MAPPING.items():
												lowerCamelCase       =      """wav2vec2_conformer.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
												if key in name or key.split("""w2v_model."""       )[-1] == name.split("""."""       )[0]:
															lowerCamelCase       =      True
															if "*" in mapped_key:
																		lowerCamelCase       =      name.split(snake_case__       )[0].split("""."""       )[-2]
																		lowerCamelCase       =      mapped_key.replace("""*""" ,				snake_case__       )
															if "pos_bias_u" in name:
																		lowerCamelCase       =      None
															elif "pos_bias_v" in name:
																		lowerCamelCase       =      None
															elif "weight_g" in name:
																		lowerCamelCase       =      """weight_g"""
															elif "weight_v" in name:
																		lowerCamelCase       =      """weight_v"""
															elif "bias" in name:
																		lowerCamelCase       =      """bias"""
															elif "weight" in name:
																		# TODO: don't match quantizer.weight_proj
																		lowerCamelCase       =      """weight"""
															elif "running_mean" in name:
																		lowerCamelCase       =      """running_mean"""
															elif "inv_freq" in name:
																		lowerCamelCase       =      """inv_freq"""
															elif "running_var" in name:
																		lowerCamelCase       =      """running_var"""
															elif "num_batches_tracked" in name:
																		lowerCamelCase       =      """num_batches_tracked"""
															else:
																		lowerCamelCase       =      None
															set_recursively(snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__       )
												continue
						if not is_used:
									unused_weights.append(snake_case__       )

			logger.warning(F'Unused weights: {unused_weights}'       )



def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__       )		->      List[Any]:
			lowerCamelCase       =      full_name.split("""conv_layers."""       )[-1]
			lowerCamelCase       =      name.split("""."""       )
			lowerCamelCase       =      int(items[0]       )
			lowerCamelCase       =      int(items[1]       )

			if type_id == 0:
						if "bias" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
												raise ValueError(
												    F'{full_name} has size {value.shape}, but'
												    F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'       )
									lowerCamelCase       =      value
									logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'       )
						elif "weight" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
												raise ValueError(
												    F'{full_name} has size {value.shape}, but'
												    F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'       )
									lowerCamelCase       =      value
									logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'       )
			elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
						if "bias" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
												raise ValueError(
												    F'{full_name} has size {value.shape}, but'
												    F' {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.'       )
									lowerCamelCase       =      value
									logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'       )
						elif "weight" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
												raise ValueError(
												    F'{full_name} has size {value.shape}, but'
												    F' {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.'       )
									lowerCamelCase       =      value
									logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'       )
			else:
						unused_weights.append(snake_case__       )



@torch.no_grad()
def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__=None ,				snake_case__=None ,				snake_case__=True       )		->      List[Any]:
			if config_path is not None:
						lowerCamelCase       =      WavaVecaConformerConfig.from_pretrained(snake_case__ ,				hidden_act="""swish"""       )
			else:
						lowerCamelCase       =      WavaVecaConformerConfig()

			if "rope" in checkpoint_path:
						lowerCamelCase       =      """rotary"""

			if is_finetuned:
						if dict_path:
									lowerCamelCase       =      Dictionary.load(snake_case__       )

									# important change bos & pad token id since CTC symbol is <pad> and
									# not <s> as in fairseq
									lowerCamelCase       =      target_dict.pad_index
									lowerCamelCase       =      target_dict.bos_index
									lowerCamelCase       =      target_dict.eos_index
									lowerCamelCase       =      len(target_dict.symbols       )
									lowerCamelCase       =      os.path.join(snake_case__ ,				"""vocab.json"""       )
									if not os.path.isdir(snake_case__       ):
												logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(snake_case__       )       )
												return
									os.makedirs(snake_case__ ,				exist_ok=snake_case__       )
									lowerCamelCase       =      target_dict.indices

									# fairseq has the <pad> and <s> switched
									lowerCamelCase       =      0
									lowerCamelCase       =      1
									with open(snake_case__ ,				"""w""" ,				encoding="""utf-8"""       ) as vocab_handle:
												json.dump(snake_case__ ,				snake_case__       )
									lowerCamelCase       =      WavaVecaCTCTokenizer(
									    snake_case__ ,				unk_token=target_dict.unk_word ,				pad_token=target_dict.pad_word ,				bos_token=target_dict.bos_word ,				eos_token=target_dict.eos_word ,				word_delimiter_token="""|""" ,				do_lower_case=snake_case__ ,				)
									lowerCamelCase       =      True if config.feat_extract_norm == """layer""" else False
									lowerCamelCase       =      WavaVecaFeatureExtractor(
									    feature_size=1 ,				sampling_rate=1_60_00 ,				padding_value=0 ,				do_normalize=snake_case__ ,				return_attention_mask=snake_case__ ,				)
									lowerCamelCase       =      WavaVecaProcessor(feature_extractor=snake_case__ ,				tokenizer=snake_case__       )
									processor.save_pretrained(snake_case__       )

						lowerCamelCase       =      WavaVecaConformerForCTC(snake_case__       )
			else:
						lowerCamelCase       =      WavaVecaConformerForPreTraining(snake_case__       )

			if is_finetuned:
						lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      fairseq.checkpoint_utils.load_model_ensemble_and_task(
						    [checkpoint_path] ,				arg_overrides={"""data""": """/""".join(dict_path.split("""/"""       )[:-1]       )}       )
			else:
						lowerCamelCase       =      argparse.Namespace(task="""audio_pretraining"""       )
						lowerCamelCase       =      fairseq.tasks.setup_task(snake_case__       )

						lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] ,				task=snake_case__       )

			lowerCamelCase       =      model[0].eval()

			recursively_load_weights(snake_case__ ,				snake_case__ ,				not is_finetuned       )

			hf_wavavec.save_pretrained(snake_case__       )


if __name__ == "__main__":
					lowerCAmelCase							:    Dict  							=							argparse.ArgumentParser()
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
					parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
					parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
					parser.add_argument(
					    """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
					)
					lowerCAmelCase							:    int  							=							parser.parse_args()
					convert_wavaveca_conformer_checkpoint(
					    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
					)









"""simple docstring"""




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


lowerCAmelCase							:    List[Any]  							=							pytest.mark.integration






@require_faiss
class 					__magic_name__							( UpperCAmelCase__       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(_a				) for x in np.arange(30				).tolist()]}				)
							return dset





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							import faiss

							lowerCamelCase       =      self._create_dummy_dataset()
							lowerCamelCase       =      dset.map(
							    lambda _a	,				_a				: {"vecs": i * np.ones(5	,				dtype=np.floataa				)}	,				with_indices=_a	,				keep_in_memory=_a				)
							lowerCamelCase       =      dset.add_faiss_index("""vecs"""	,				batch_size=100	,				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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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=100	,				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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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=_a				) 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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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(_a	,				partial(dset.get_nearest_examples	,				"""vecs2"""	,				np.ones(5	,				dtype=np.floataa				)				)				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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=_a				)
										lowerCamelCase   ,     lowerCamelCase       =      dset.get_nearest_examples("""filename"""	,				"""my_name-train_29"""				)
										self.assertEqual(examples["""filename"""][0]	,				"""my_name-train_29"""				)






@require_faiss
class 					__magic_name__							( UpperCAmelCase__       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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(_a				)
							self.assertRaises(_a	,				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(_a				)
							self.assertRaises(_a	,				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(_a				)	,				0				)
							self.assertListEqual([4, 3, 2, 1, 0]	,				_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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(_a				):
										lowerCamelCase       =      FaissIndex(string_factory="""Flat"""	,				custom_index=faiss.IndexFlat(5				)				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							import faiss

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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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=_a				) 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(_a				)
							self.assertGreater(scores[0]	,				0				)
							self.assertEqual(indices[0]	,				1				)




@require_faiss
def 					a__				(       snake_case__       )		->      Tuple:
			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(snake_case__ ,				storage_options=mockfs.storage_options       )
			lowerCamelCase       =      FaissIndex.load(snake_case__ ,				storage_options=mockfs.storage_options       )

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






@require_elasticsearch
class 					__magic_name__							( UpperCAmelCase__       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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=_a				)
										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(_a				)
										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(_a	,				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(_a				)
										lowerCamelCase       =      [scores[0] for scores in total_scores]
										lowerCamelCase       =      [indices[0] for indices in total_indices]
										self.assertGreater(np.min(_a				)	,				0				)
										self.assertListEqual([1, 1, 1]	,				_a				)

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



