
"""simple docstring"""




import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 			__magic_name__       (       SCREAMING_SNAKE_CASE__   ,					unittest.TestCase ):
       UpperCamelCase_   =		MobileBertTokenizer
       UpperCamelCase_   =		MobileBertTokenizerFast
       UpperCamelCase_   =		True
       UpperCamelCase_   =		True
       UpperCamelCase_   =		filter_non_english
       UpperCamelCase_   =		'''google/mobilebert-uncased'''
       def 							lowercase_							(     self       )     ->	str:





         """simple docstring"""




         super().setUp()

         _lowercase:			Tuple       =     [
             '''[UNK]''',
             '''[CLS]''',
             '''[SEP]''',
             '''[PAD]''',
             '''[MASK]''',
             '''want''',
             '''##want''',
             '''##ed''',
             '''wa''',
             '''un''',
             '''runn''',
             '''##ing''',
             ''',''',
             '''low''',
             '''lowest''',
         ]
         _lowercase:			Optional[int]       =     os.path.join(self.tmpdirname ,				VOCAB_FILES_NAMES['''vocab_file''']       )
         with open(self.vocab_file ,				'''w''' ,				encoding='''utf-8'''       ) as vocab_writer:
           vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )

         _lowercase:			List[str]       =     [
             (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
             for tokenizer_def in self.tokenizers_list
         ]
       def 							lowercase_							(     self ,				A_       )     ->	Union[str, Any]:





         """simple docstring"""




         _lowercase:			Union[str, Any]       =     '''UNwant\u00E9d,running'''
         _lowercase:			Union[str, Any]       =     '''unwanted, running'''
         return input_text, output_text
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         _lowercase:			Optional[int]       =     self.tokenizer_class(self.vocab_file       )

         _lowercase:			Optional[int]       =     tokenizer.tokenize('''UNwant\u00E9d,running'''       )
         self.assertListEqual(A_ ,				['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']       )
         self.assertListEqual(tokenizer.convert_tokens_to_ids(A_       ) ,				[9, 6, 7, 12, 10, 11]       )
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         if not self.test_rust_tokenizer:
           return

         _lowercase:			Any       =     self.get_tokenizer()
         _lowercase:			str       =     self.get_rust_tokenizer()

         _lowercase:			Optional[int]       =     '''UNwant\u00E9d,running'''

         _lowercase:			List[str]       =     tokenizer.tokenize(A_       )
         _lowercase:			Optional[int]       =     rust_tokenizer.tokenize(A_       )
         self.assertListEqual(A_ ,				A_       )

         _lowercase:			Tuple       =     tokenizer.encode(A_ ,				add_special_tokens=A_       )
         _lowercase:			Dict       =     rust_tokenizer.encode(A_ ,				add_special_tokens=A_       )
         self.assertListEqual(A_ ,				A_       )

         _lowercase:			Dict       =     self.get_rust_tokenizer()
         _lowercase:			Any       =     tokenizer.encode(A_       )
         _lowercase:			Dict       =     rust_tokenizer.encode(A_       )
         self.assertListEqual(A_ ,				A_       )

         # With lower casing
         _lowercase:			str       =     self.get_tokenizer(do_lower_case=A_       )
         _lowercase:			str       =     self.get_rust_tokenizer(do_lower_case=A_       )

         _lowercase:			Dict       =     '''UNwant\u00E9d,running'''

         _lowercase:			str       =     tokenizer.tokenize(A_       )
         _lowercase:			str       =     rust_tokenizer.tokenize(A_       )
         self.assertListEqual(A_ ,				A_       )

         _lowercase:			List[str]       =     tokenizer.encode(A_ ,				add_special_tokens=A_       )
         _lowercase:			Tuple       =     rust_tokenizer.encode(A_ ,				add_special_tokens=A_       )
         self.assertListEqual(A_ ,				A_       )

         _lowercase:			Tuple       =     self.get_rust_tokenizer()
         _lowercase:			List[Any]       =     tokenizer.encode(A_       )
         _lowercase:			Optional[int]       =     rust_tokenizer.encode(A_       )
         self.assertListEqual(A_ ,				A_       )
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         _lowercase:			List[Any]       =     BasicTokenizer()

         self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''       ) ,				['''ah''', '''\u535A''', '''\u63A8''', '''zz''']       )
       def 							lowercase_							(     self       )     ->	str:





         """simple docstring"""




         _lowercase:			List[Any]       =     BasicTokenizer(do_lower_case=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''       ) ,				['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
         self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       ) ,				['''hello''']       )
       def 							lowercase_							(     self       )     ->	List[Any]:





         """simple docstring"""




         _lowercase:			Tuple       =     BasicTokenizer(do_lower_case=A_ ,				strip_accents=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       ) ,				['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
         self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       ) ,				['''h\u00E9llo''']       )
       def 							lowercase_							(     self       )     ->	int:





         """simple docstring"""




         _lowercase:			Optional[int]       =     BasicTokenizer(do_lower_case=A_ ,				strip_accents=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       ) ,				['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
         self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       ) ,				['''hello''']       )
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         _lowercase:			Any       =     BasicTokenizer(do_lower_case=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       ) ,				['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
         self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       ) ,				['''hello''']       )
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         _lowercase:			int       =     BasicTokenizer(do_lower_case=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''       ) ,				['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )
       def 							lowercase_							(     self       )     ->	List[Any]:





         """simple docstring"""




         _lowercase:			Tuple       =     BasicTokenizer(do_lower_case=A_ ,				strip_accents=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       ) ,				['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )
       def 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         _lowercase:			List[Any]       =     BasicTokenizer(do_lower_case=A_ ,				strip_accents=A_       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       ) ,				['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )
       def 							lowercase_							(     self       )     ->	Dict:





         """simple docstring"""




         _lowercase:			List[Any]       =     BasicTokenizer(do_lower_case=A_ ,				never_split=['''[UNK]''']       )

         self.assertListEqual(
             tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''       ) ,				['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']       )
       def 							lowercase_							(     self       )     ->	Optional[int]:





         """simple docstring"""




         _lowercase:			Optional[Any]       =     ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

         _lowercase:			List[Any]       =     {}
         for i, token in enumerate(A_       ):
           _lowercase:			List[str]       =     i
         _lowercase:			List[Any]       =     WordpieceTokenizer(vocab=A_ ,				unk_token='''[UNK]'''       )

         self.assertListEqual(tokenizer.tokenize(''''''       ) ,				[]       )

         self.assertListEqual(tokenizer.tokenize('''unwanted running'''       ) ,				['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']       )

         self.assertListEqual(tokenizer.tokenize('''unwantedX running'''       ) ,				['''[UNK]''', '''runn''', '''##ing''']       )
       def 							lowercase_							(     self       )     ->	Tuple:





         """simple docstring"""




         self.assertTrue(_is_whitespace(''' '''       )       )
         self.assertTrue(_is_whitespace('''\t'''       )       )
         self.assertTrue(_is_whitespace('''\r'''       )       )
         self.assertTrue(_is_whitespace('''\n'''       )       )
         self.assertTrue(_is_whitespace('''\u00A0'''       )       )

         self.assertFalse(_is_whitespace('''A'''       )       )
         self.assertFalse(_is_whitespace('''-'''       )       )
       def 							lowercase_							(     self       )     ->	Optional[int]:





         """simple docstring"""




         self.assertTrue(_is_control('''\u0005'''       )       )

         self.assertFalse(_is_control('''A'''       )       )
         self.assertFalse(_is_control(''' '''       )       )
         self.assertFalse(_is_control('''\t'''       )       )
         self.assertFalse(_is_control('''\r'''       )       )
       def 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         self.assertTrue(_is_punctuation('''-'''       )       )
         self.assertTrue(_is_punctuation('''$'''       )       )
         self.assertTrue(_is_punctuation('''`'''       )       )
         self.assertTrue(_is_punctuation('''.'''       )       )

         self.assertFalse(_is_punctuation('''A'''       )       )
         self.assertFalse(_is_punctuation(''' '''       )       )
       def 							lowercase_							(     self       )     ->	Tuple:





         """simple docstring"""




         _lowercase:			Tuple       =     self.get_tokenizer()
         _lowercase:			str       =     self.get_rust_tokenizer()

         # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
         self.assertListEqual([tokenizer.tokenize(A_       ) for t in ['''Test''', '''\xad''', '''test''']] ,				[['''[UNK]'''], [], ['''[UNK]''']]       )

         self.assertListEqual(
             [rust_tokenizer.tokenize(A_       ) for t in ['''Test''', '''\xad''', '''test''']] ,				[['''[UNK]'''], [], ['''[UNK]''']]       )
       @slow
       def 							lowercase_							(     self       )     ->	Dict:





         """simple docstring"""




         _lowercase:			Any       =     self.tokenizer_class.from_pretrained('''google/mobilebert-uncased'''       )

         _lowercase:			List[str]       =     tokenizer.encode('''sequence builders''' ,				add_special_tokens=A_       )
         _lowercase:			Tuple       =     tokenizer.encode('''multi-sequence build''' ,				add_special_tokens=A_       )

         _lowercase:			List[Any]       =     tokenizer.build_inputs_with_special_tokens(A_       )
         _lowercase:			List[str]       =     tokenizer.build_inputs_with_special_tokens(A_ ,				A_       )

         assert encoded_sentence == [101] + text + [102]
         assert encoded_pair == [101] + text + [102] + text_a + [102]
       def 							lowercase_							(     self       )     ->	str:





         """simple docstring"""




         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
             _lowercase:			Optional[int]       =     self.rust_tokenizer_class.from_pretrained(A_ ,				**A_       )

             _lowercase:			Union[str, Any]       =     f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
             _lowercase:			Union[str, Any]       =     tokenizer_r.encode_plus(
                 A_ ,				return_attention_mask=A_ ,				return_token_type_ids=A_ ,				return_offsets_mapping=A_ ,				add_special_tokens=A_ ,				)

             _lowercase:			List[str]       =     tokenizer_r.do_lower_case if hasattr(A_ ,				'''do_lower_case'''       ) else False
             _lowercase:			str       =     (
                 [
                     ((0, 0), tokenizer_r.cls_token),
                     ((0, 1), '''A'''),
                     ((1, 2), ''','''),
                     ((3, 5), '''na'''),
                     ((5, 6), '''##ï'''),
                     ((6, 8), '''##ve'''),
                     ((9, 15), tokenizer_r.mask_token),
                     ((16, 21), '''Allen'''),
                     ((21, 23), '''##NL'''),
                     ((23, 24), '''##P'''),
                     ((25, 33), '''sentence'''),
                     ((33, 34), '''.'''),
                     ((0, 0), tokenizer_r.sep_token),
                 ]
                 if not do_lower_case
                 else [
                     ((0, 0), tokenizer_r.cls_token),
                     ((0, 1), '''a'''),
                     ((1, 2), ''','''),
                     ((3, 8), '''naive'''),
                     ((9, 15), tokenizer_r.mask_token),
                     ((16, 21), '''allen'''),
                     ((21, 23), '''##nl'''),
                     ((23, 24), '''##p'''),
                     ((25, 33), '''sentence'''),
                     ((33, 34), '''.'''),
                     ((0, 0), tokenizer_r.sep_token),
                 ]
             )

             self.assertEqual(
                 [e[1] for e in expected_results] ,				tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']       )       )
             self.assertEqual([e[0] for e in expected_results] ,				tokens['''offset_mapping''']       )



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





         """simple docstring"""




         _lowercase:			Dict       =     ['''的''', '''人''', '''有''']
         _lowercase:			Union[str, Any]       =     ''''''.join(A_       )
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''       ):
             _lowercase:			int       =     True
             _lowercase:			Union[str, Any]       =     self.tokenizer_class.from_pretrained(A_ ,				**A_       )
             _lowercase:			Any       =     self.rust_tokenizer_class.from_pretrained(A_ ,				**A_       )

             _lowercase:			List[Any]       =     tokenizer_p.encode(A_ ,				add_special_tokens=A_       )
             _lowercase:			Dict       =     tokenizer_r.encode(A_ ,				add_special_tokens=A_       )

             _lowercase:			Dict       =     tokenizer_r.convert_ids_to_tokens(A_       )
             _lowercase:			Optional[int]       =     tokenizer_p.convert_ids_to_tokens(A_       )

             # it is expected that each Chinese character is not preceded by "##"
             self.assertListEqual(A_ ,				A_       )
             self.assertListEqual(A_ ,				A_       )

             _lowercase:			Optional[int]       =     False
             _lowercase:			List[str]       =     self.rust_tokenizer_class.from_pretrained(A_ ,				**A_       )
             _lowercase:			Any       =     self.tokenizer_class.from_pretrained(A_ ,				**A_       )

             _lowercase:			List[Any]       =     tokenizer_r.encode(A_ ,				add_special_tokens=A_       )
             _lowercase:			Optional[int]       =     tokenizer_p.encode(A_ ,				add_special_tokens=A_       )

             _lowercase:			Tuple       =     tokenizer_r.convert_ids_to_tokens(A_       )
             _lowercase:			Tuple       =     tokenizer_p.convert_ids_to_tokens(A_       )

             # it is expected that only the first Chinese character is not preceded by "##".
             _lowercase:			str       =     [
                 f'''##{token}''' if idx != 0 else token for idx, token in enumerate(A_       )
             ]
             self.assertListEqual(A_ ,				A_       )
             self.assertListEqual(A_ ,				A_       )


"""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


A__   :					Any							=   pytest.mark.integration


@require_faiss
class 			__magic_name__       (       SCREAMING_SNAKE_CASE__ ):
       def 							lowercase_							(     self       )     ->	List[Any]:





         """simple docstring"""




         _lowercase:			str       =     Dataset.from_dict({'''filename''': ['''my_name-train''' + '''_''' + str(A_       ) for x in np.arange(30       ).tolist()]}       )
         return dset
       def 							lowercase_							(     self       )     ->	int:





         """simple docstring"""




         import faiss

         _lowercase:			Dataset       =     self._create_dummy_dataset()
         _lowercase:			List[str]       =     dset.map(
             lambda A_ ,				A_       : {"vecs": i * np.ones(5 ,				dtype=np.floataa       )} ,				with_indices=A_ ,				keep_in_memory=A_       )
         _lowercase:			Dict       =     dset.add_faiss_index('''vecs''' ,				batch_size=100 ,				metric_type=faiss.METRIC_INNER_PRODUCT       )
         _lowercase ,				_lowercase:			Union[str, Any]       =     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       )     ->	List[Any]:





         """simple docstring"""




         import faiss

         _lowercase:			Dataset       =     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 ,				)
         _lowercase ,				_lowercase:			Dict       =     dset.get_nearest_examples('''vecs''' ,				np.ones(5 ,				dtype=np.floataa       )       )
         self.assertEqual(examples['''filename'''][0] ,				'''my_name-train_29'''       )
       def 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         import faiss

         _lowercase:			Dataset       =     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       )

         _lowercase ,				_lowercase:			Dict       =     dset.get_nearest_examples('''vecs2''' ,				np.ones(5 ,				dtype=np.floataa       )       )
         self.assertEqual(examples['''filename'''][0] ,				'''my_name-train_29'''       )
       def 							lowercase_							(     self       )     ->	int:





         """simple docstring"""




         _lowercase:			Dataset       =     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 							lowercase_							(     self       )     ->	List[Any]:





         """simple docstring"""




         from elasticsearch import Elasticsearch

         _lowercase:			Dataset       =     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:
           _lowercase:			List[Any]       =     {'''acknowledged''': True}
           mocked_bulk.return_value([(True, None)] * 30       )
           _lowercase:			List[str]       =     {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 29}]}}
           _lowercase:			int       =     Elasticsearch()

           dset.add_elasticsearch_index('''filename''' ,				es_client=A_       )
           _lowercase ,				_lowercase:			Dict       =     dset.get_nearest_examples('''filename''' ,				'''my_name-train_29'''       )
           self.assertEqual(examples['''filename'''][0] ,				'''my_name-train_29'''       )


@require_faiss
class 			__magic_name__       (       SCREAMING_SNAKE_CASE__ ):
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         import faiss

         _lowercase:			str       =     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
         _lowercase:			List[Any]       =     np.zeros(5 ,				dtype=np.floataa       )
         _lowercase:			int       =     1
         _lowercase ,				_lowercase:			Optional[Any]       =     index.search(A_       )
         self.assertRaises(A_ ,				index.search ,				query.reshape(-1 ,				1       )       )
         self.assertGreater(scores[0] ,				0       )
         self.assertEqual(indices[0] ,				1       )

         # batched queries
         _lowercase:			Tuple       =     np.eye(5 ,				dtype=np.floataa       )[::-1]
         _lowercase ,				_lowercase:			str       =     index.search_batch(A_       )
         self.assertRaises(A_ ,				index.search_batch ,				queries[0]       )
         _lowercase:			Tuple       =     [scores[0] for scores in total_scores]
         _lowercase:			Union[str, Any]       =     [indices[0] for indices in total_indices]
         self.assertGreater(np.min(A_       ) ,				0       )
         self.assertListEqual([4, 3, 2, 1, 0] ,				A_       )
       def 							lowercase_							(     self       )     ->	Union[str, Any]:





         """simple docstring"""




         import faiss

         _lowercase:			Union[str, Any]       =     FaissIndex(string_factory='''Flat'''       )
         index.add_vectors(np.eye(5 ,				dtype=np.floataa       )       )
         self.assertIsInstance(index.faiss_index ,				faiss.IndexFlat       )
         _lowercase:			Dict       =     FaissIndex(string_factory='''LSH'''       )
         index.add_vectors(np.eye(5 ,				dtype=np.floataa       )       )
         self.assertIsInstance(index.faiss_index ,				faiss.IndexLSH       )
         with self.assertRaises(A_       ):
           _lowercase:			List[str]       =     FaissIndex(string_factory='''Flat''' ,				custom_index=faiss.IndexFlat(5       )       )
       def 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         import faiss

         _lowercase:			Any       =     faiss.IndexFlat(5       )
         _lowercase:			List[Any]       =     FaissIndex(custom_index=A_       )
         index.add_vectors(np.eye(5 ,				dtype=np.floataa       )       )
         self.assertIsInstance(index.faiss_index ,				faiss.IndexFlat       )



       def 							lowercase_							(     self       )     ->	str:





         """simple docstring"""




         import faiss

         _lowercase:			Tuple       =     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       )
           _lowercase:			Optional[Any]       =     FaissIndex.load(tmp_file.name       )
         os.unlink(tmp_file.name       )

         _lowercase:			Optional[Any]       =     np.zeros(5 ,				dtype=np.floataa       )
         _lowercase:			Union[str, Any]       =     1
         _lowercase ,				_lowercase:			Tuple       =     index.search(A_       )
         self.assertGreater(scores[0] ,				0       )
         self.assertEqual(indices[0] ,				1       )




@require_faiss
def  _lowerCAmelCase		(		_UpperCamelCase						):






  """simple docstring"""



  import faiss

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

  _lowercase:			Tuple       =     '''index.faiss'''
  _lowercase:			str       =     f'''mock://{index_name}'''
  index.save(_UpperCamelCase ,				storage_options=mockfs.storage_options						)
  _lowercase:			List[Any]       =     FaissIndex.load(_UpperCamelCase ,				storage_options=mockfs.storage_options						)

  _lowercase:			Union[str, Any]       =     np.zeros(5 ,				dtype=np.floataa						)
  _lowercase:			Dict       =     1
  _lowercase ,				_lowercase:			str       =     index.search(_UpperCamelCase						)
  assert scores[0] > 0
  assert indices[0] == 1







@require_elasticsearch
class 			__magic_name__       (       SCREAMING_SNAKE_CASE__ ):
       def 							lowercase_							(     self       )     ->	int:





         """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:
           _lowercase:			int       =     Elasticsearch()
           _lowercase:			Tuple       =     {'''acknowledged''': True}
           _lowercase:			Tuple       =     ElasticSearchIndex(es_client=A_       )
           mocked_bulk.return_value([(True, None)] * 3       )
           index.add_documents(['''foo''', '''bar''', '''foobar''']       )

           # single query
           _lowercase:			Dict       =     '''foo'''
           _lowercase:			Union[str, Any]       =     {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 0}]}}
           _lowercase ,				_lowercase:			Optional[Any]       =     index.search(A_       )
           self.assertEqual(scores[0] ,				1       )
           self.assertEqual(indices[0] ,				0       )

           # single query with timeout
           _lowercase:			Optional[int]       =     '''foo'''
           _lowercase:			Union[str, Any]       =     {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 0}]}}
           _lowercase ,				_lowercase:			List[Any]       =     index.search(A_ ,				request_timeout=30       )
           self.assertEqual(scores[0] ,				1       )
           self.assertEqual(indices[0] ,				0       )

           # batched queries
           _lowercase:			Union[str, Any]       =     ['''foo''', '''bar''', '''foobar''']
           _lowercase:			str       =     {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 1}]}}
           _lowercase ,				_lowercase:			Optional[int]       =     index.search_batch(A_       )
           _lowercase:			Any       =     [scores[0] for scores in total_scores]
           _lowercase:			List[str]       =     [indices[0] for indices in total_indices]
           self.assertGreater(np.min(A_       ) ,				0       )
           self.assertListEqual([1, 1, 1] ,				A_       )

           # batched queries with timeout
           _lowercase:			List[str]       =     ['''foo''', '''bar''', '''foobar''']
           _lowercase:			Dict       =     {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 1}]}}
           _lowercase ,				_lowercase:			Optional[int]       =     index.search_batch(A_ ,				request_timeout=30       )
           _lowercase:			Optional[Any]       =     [scores[0] for scores in total_scores]
           _lowercase:			Dict       =     [indices[0] for indices in total_indices]
           self.assertGreater(np.min(A_       ) ,				0       )
           self.assertListEqual([1, 1, 1] ,				A_       )
