




'''simple docstring'''


import json
import os
from datetime import date
from pathlib import Path

from tabulate import DataRow, TableFormat, tabulate


_lowercase  =			TableFormat(
    lineabove=None,
    linebelowheader=None,
    linebetweenrows=None,
    linebelow=None,
    headerrow=DataRow("""""", """|""", """|"""),
    datarow=DataRow("""""", """|""", """|"""),
    padding=1,
    with_header_hide=None,
)


_lowercase  =			[]
_lowercase  =			[]

_lowercase  =			{"""type""": """section""", """text""": {"""type""": """plain_text""", """text""": """No failed tests! 🤗""", """emoji""": True}}

_lowercase  =			[
    {
        """type""": """header""",
        """text""": {
            """type""": """plain_text""",
            """text""": f'''🤗 Accelerate nightly {os.environ.get('TEST_TYPE', '')} test results''',
            """emoji""": True,
        },
    }
]

_lowercase  =			0
for log in Path().glob("""*.log"""):
	_lowercase  =			0
	with open(log, """r""") as f:
		for line in f:
			_lowercase  =			json.loads(line)
			if line.get("""nodeid""", """""") != "":
				_lowercase  =			line["""nodeid"""]
				if line.get("""duration""", None) is not None:
					_lowercase  =			f'''{line['duration']:.4f}'''
					if line.get("""outcome""", """""") == "failed":
						section_num_failed += 1
						failed.append([test, duration, log.name.split("""_""")[0]])
						total_num_failed += 1
	group_info.append([str(log), section_num_failed, failed])
	_lowercase  =			[]
	log.unlink()

_lowercase  =			""""""
_lowercase  =			[]
if total_num_failed > 0:
	for name, num_failed, failed_tests in group_info:
		if num_failed > 0:
			if num_failed == 1:
				message += f"*{name[1:]}: {num_failed} failed test*\n"
			else:
				message += f"*{name[1:]}: {num_failed} failed tests*\n"
			_lowercase  =			[]
			_lowercase  =			{}
			for test in failed_tests:
				_lowercase  =			test[0].split("""::""")
				_lowercase  =			data[0].split("""/""")[-1]
				if data[0] not in filesafailed:
					_lowercase  =			[data[1:]]
				else:
					filesafailed[data[0]] += [data[1:]]
				failed_table.append(data)

			_lowercase  =			[test[0] for test in failed_table]
			_lowercase  =			list(set(files))
			# Count number of instances in failed_tests
			_lowercase  =			[]
			for file in individual_files:
				table.append([file, len(filesafailed[file])])

			_lowercase  =			tabulate(
			    table,
			    headers=["""Test Location""", """Num Failed"""],
			    tablefmt=hf_table_format,
			    stralign="""right""",
			)
			message += f"\n```\n{failed_table}\n```"
			all_filesafailed.append(filesafailed)
	if len(message) > 30_00:
		_lowercase  =			"""Too many failed tests, please see the full report in the Action results."""
		_lowercase  =			len(err) + 10
		_lowercase  =			message[: 30_00 - offset] + f'''\n...\n```\n{err}'''
	print(f'''### {message}''')
else:
	_lowercase  =			"""No failed tests! 🤗"""
	print(f'''## {message}''')
	payload.append(no_error_payload)

if os.environ.get("""TEST_TYPE""", """""") != "":
	from slack_sdk import WebClient

	_lowercase  =			WebClient(token=os.environ["""SLACK_API_TOKEN"""])
	if message != "No failed tests! 🤗":
		_lowercase  =			{
		    """type""": """section""",
		    """text""": {
		        """type""": """mrkdwn""",
		        """text""": message,
		    },
		}
		payload.append(md_report)
		_lowercase  =			{
		    """type""": """section""",
		    """text""": {
		        """type""": """mrkdwn""",
		        """text""": """*For more details:*""",
		    },
		    """accessory""": {
		        """type""": """button""",
		        """text""": {
		            """type""": """plain_text""",
		            """text""": """Check Action results""",
		            """emoji""": True,
		        },
		        """url""": f'''https://github.com/{os.environ['GITHUB_REPOSITORY']}/actions/runs/{os.environ['GITHUB_RUN_ID']}''',
		    },
		}
		payload.append(action_button)
		_lowercase  =			{
		    """type""": """context""",
		    """elements""": [
		        {
		            """type""": """plain_text""",
		            """text""": f'''Nightly {os.environ.get('TEST_TYPE')} test results for {date.today()}''',
		        }
		    ],
		}
		payload.append(date_report)
	_lowercase  =			client.chat_postMessage(channel="""#accelerate-ci-daily""", text=message, blocks=payload)
	_lowercase  =			response.data["""ts"""]
	for failed_file in all_filesafailed:
		for test_location, test_failures in failed_file.items():
			# Keep only the first instance of the test name
			_lowercase  =			""""""
			for i, row in enumerate(test_failures):
				if row[0] != test_class:
					_lowercase  =			row[0]
				else:
					_lowercase  =			""""""

			_lowercase  =			{
			    """type""": """section""",
			    """text""": {
			        """type""": """mrkdwn""",
			        """text""": f'''Test location: {test_location}\n```\n{tabulate(test_failures, headers=['Class', 'Test'], tablefmt=hf_table_format, stralign='right')}\n```''',
			    },
			}

			client.chat_postMessage(
			    channel="""#accelerate-ci-daily""",
			    thread_ts=ts,
			    blocks=[payload],
			)







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


_lowercase  =			pytest.mark.integration
@require_faiss
class 						a_				(			UpperCAmelCase__						):




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




	def   lowercase__   (       self     :  List[str]      ):
							import faiss

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




	def   lowercase__   (       self     :  Optional[int]      ):
							import faiss

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




	def   lowercase__   (       self     :  Dict      ):
							import faiss

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

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

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




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




	def   lowercase__   (       self     :  List[str]      ):
							from elasticsearch import Elasticsearch

							__snake_case						 =   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:
													__snake_case						 =   {'acknowledged': True}
													mocked_bulk.return_value([(True, None)] * 3_0      )
													__snake_case						 =   {'hits': {'hits': [{'_score': 1, '_id': 2_9}]}}
													__snake_case						 =   Elasticsearch()

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





@require_faiss
class 						a_				(			UpperCAmelCase__						):




	def   lowercase__   (       self     :  Dict      ):
							import faiss

							__snake_case						 =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT      )

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

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

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




	def   lowercase__   (       self     :  Optional[int]      ):
							import faiss

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




	def   lowercase__   (       self     :  int      ):
							import faiss

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




	def   lowercase__   (       self     :  Tuple      ):
							import faiss

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

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

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





@require_faiss
def 						lowerCamelCase__   (				a							):
						import faiss

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

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

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






@require_elasticsearch
class 						a_				(			UpperCAmelCase__						):




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

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

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

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

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

