






from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
UpperCAmelCase__				   =		Lock()
def 						_a    (      a :Optional[int]	,							a :List[Any]	,							a :List[str]	,							a :Union[str, Any]	,							a :Tuple	,							a :Union[str, Any]	,							a :List[Any] )							->			Tuple:
 global process_lock

 # we perform n swaps since after n swaps we know we are sorted
 # we *could* stop early if we are sorted already, but it takes as long to
 # find out we are sorted as it does to sort the list with this algorithm
 for i in range(0	,							10 ):
  if (i + position) % 2 == 0 and r_send is not None:
   # send your value to your right neighbor
   process_lock.acquire()
   r_send[1].send(a )
   process_lock.release()

   # receive your right neighbor's value
   process_lock.acquire()
   a		  =      rr_cv[0].recv()
   process_lock.release()

   # take the lower value since you are on the left
   a		  =      min(a	,							a )
  elif (i + position) % 2 != 0 and l_send is not None:
   # send your value to your left neighbor
   process_lock.acquire()
   l_send[1].send(a )
   process_lock.release()

   # receive your left neighbor's value
   process_lock.acquire()
   a		  =      lr_cv[0].recv()
   process_lock.release()

   # take the higher value since you are on the right
   a		  =      max(a	,							a )
    # after all swaps are performed, send the values back to main
 result_pipe[1].send(a )
def 						_a    (      a :Union[str, Any] )							->			Optional[Any]:
 a		  =      []
 a		  =      []
 # initialize the list of pipes where the values will be retrieved
 for _ in arr:
  result_pipe.append(Pipe() )
 # creates the processes
 # the first and last process only have one neighbor so they are made outside
 # of the loop
 a		  =      Pipe()
 a		  =      Pipe()
 process_array_.append(
     Process(
         target=a	,							args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])	,							) )
 a		  =      temp_rs
 a		  =      temp_rr

 for i in range(1	,							len(a ) - 1 ):
  a		  =      Pipe()
  a		  =      Pipe()
  process_array_.append(
      Process(
          target=a	,							args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])	,							) )
  a		  =      temp_rs
  a		  =      temp_rr

 process_array_.append(
     Process(
         target=a	,							args=(
             len(a ) - 1,
             arr[len(a ) - 1],
             temp_ls,
             None,
             temp_lr,
             None,
             result_pipe[len(a ) - 1],
         )	,							) )

 # start the processes
 for p in process_array_:
  p.start()

 # wait for the processes to end and write their values to the list
 for p in range(0	,							len(a ) ):
  a		  =      result_pipe[p][0].recv()
  process_array_[p].join()
 return arr
def 						_a    (      )							->			int:
 a		  =      list(range(10	,							0	,							-1 ) )
 print('''Initial List''' )
 print(*a )
 a		  =      odd_even_transposition(a )
 print('''Sorted List\n''' )
 print(*a )


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


UpperCAmelCase__				   =		pytest.mark.integration






@require_faiss
class 		lowercase_					(	lowercase   ):






      '''simple docstring'''




      def       __lowerCAmelCase					(      self      :						Tuple  )    ->Any:




       """simple docstring"""


       a		  =      Dataset.from_dict({'''filename''': ['''my_name-train''' + '''_''' + str(__UpperCAmelCase  ) for x in np.arange(30  ).tolist()]}  )
       return dset







      def       __lowerCAmelCase					(      self      :						Tuple  )    ->Any:




       """simple docstring"""


       import faiss

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




       """simple docstring"""


       import faiss

       a		  =      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 ,					)
       a  ,     a		  =      dset.get_nearest_examples('''vecs''' ,					np.ones(5 ,					dtype=np.floataa  )  )
       self.assertEqual(examples['''filename'''][0] ,					'''my_name-train_29'''  )







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




       """simple docstring"""


       import faiss

       a		  =      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=__UpperCAmelCase  ) as tmp_file:
        dset.save_faiss_index('''vecs''' ,					tmp_file.name  )
        dset.load_faiss_index('''vecs2''' ,					tmp_file.name  )
       os.unlink(tmp_file.name  )

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







      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->Any:




       """simple docstring"""


       a		  =      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(__UpperCAmelCase ,					partial(dset.get_nearest_examples ,					'''vecs2''' ,					np.ones(5 ,					dtype=np.floataa  )  )  )







      def       __lowerCAmelCase					(      self      :						List[Any]  )    ->List[str]:




       """simple docstring"""


       from elasticsearch import Elasticsearch

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

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






@require_faiss
class 		lowercase_					(	lowercase   ):






      '''simple docstring'''




      def       __lowerCAmelCase					(      self      :						Any  )    ->Any:




       """simple docstring"""


       import faiss

       a		  =      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
       a		  =      np.zeros(5 ,					dtype=np.floataa  )
       a		  =      1
       a  ,     a		  =      index.search(__UpperCAmelCase  )
       self.assertRaises(__UpperCAmelCase ,					index.search ,					query.reshape(-1 ,					1  )  )
       self.assertGreater(scores[0] ,					0  )
       self.assertEqual(indices[0] ,					1  )

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







      def       __lowerCAmelCase					(      self      :						Any  )    ->List[Any]:




       """simple docstring"""


       import faiss

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







      def       __lowerCAmelCase					(      self      :						int  )    ->Optional[Any]:




       """simple docstring"""


       import faiss

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







      def       __lowerCAmelCase					(      self      :						int  )    ->Dict:




       """simple docstring"""


       import faiss

       a		  =      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=__UpperCAmelCase  ) as tmp_file:
        index.save(tmp_file.name  )
        a		  =      FaissIndex.load(tmp_file.name  )
       os.unlink(tmp_file.name  )

       a		  =      np.zeros(5 ,					dtype=np.floataa  )
       a		  =      1
       a  ,     a		  =      index.search(__UpperCAmelCase  )
       self.assertGreater(scores[0] ,					0  )
       self.assertEqual(indices[0] ,					1  )
@require_faiss
def 						_a    (      a :Dict )							->			Any:
 import faiss

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

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

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






@require_elasticsearch
class 		lowercase_					(	lowercase   ):






      '''simple docstring'''




      def       __lowerCAmelCase					(      self      :						int  )    ->List[Any]:




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

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

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

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

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


