
import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers.models.esm.modeling_esmfold import EsmForProteinFolding




class     _SCREAMING_SNAKE_CASE     :



	def __init__(    self						,  lowercase						,  lowercase=13						,  lowercase=7						,  lowercase=False						,  lowercase=True						,  lowercase=False						,  lowercase=False						,  lowercase=19						,  lowercase=32						,  lowercase=5						,  lowercase=4						,  lowercase=37						,  lowercase="gelu"						,  lowercase=0.1						,  lowercase=0.1						,  lowercase=512						,  lowercase=16						,  lowercase=2						,  lowercase=0.0_2						,  lowercase=3						,  lowercase=4						,  lowercase=None						,  )				->       List[Any]:
					lowerCamelCase_						=			parent
					lowerCamelCase_						=			batch_size
					lowerCamelCase_						=			seq_length
					lowerCamelCase_						=			is_training
					lowerCamelCase_						=			use_input_mask
					lowerCamelCase_						=			use_token_type_ids
					lowerCamelCase_						=			use_labels
					lowerCamelCase_						=			vocab_size
					lowerCamelCase_						=			hidden_size
					lowerCamelCase_						=			num_hidden_layers
					lowerCamelCase_						=			num_attention_heads
					lowerCamelCase_						=			intermediate_size
					lowerCamelCase_						=			hidden_act
					lowerCamelCase_						=			hidden_dropout_prob
					lowerCamelCase_						=			attention_probs_dropout_prob
					lowerCamelCase_						=			max_position_embeddings
					lowerCamelCase_						=			type_vocab_size
					lowerCamelCase_						=			type_sequence_label_size
					lowerCamelCase_						=			initializer_range
					lowerCamelCase_						=			num_labels
					lowerCamelCase_						=			num_choices
					lowerCamelCase_						=			scope



	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					lowerCamelCase_						=			ids_tensor([self.batch_size, self.seq_length]						,  self.vocab_size )

					lowerCamelCase_						=			None
					if self.use_input_mask:
									lowerCamelCase_						=			random_attention_mask([self.batch_size, self.seq_length] )

					lowerCamelCase_						=			None
					lowerCamelCase_						=			None
					lowerCamelCase_						=			None
					if self.use_labels:
									lowerCamelCase_						=			ids_tensor([self.batch_size]						,  self.type_sequence_label_size )
									lowerCamelCase_						=			ids_tensor([self.batch_size, self.seq_length]						,  self.num_labels )
									lowerCamelCase_						=			ids_tensor([self.batch_size]						,  self.num_choices )

					lowerCamelCase_						=			self.get_config()

					return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					lowerCamelCase_						=			EsmConfig(
					    vocab_size=33						,  hidden_size=self.hidden_size						,  pad_token_id=1						,  num_hidden_layers=self.num_hidden_layers						,  num_attention_heads=self.num_attention_heads						,  intermediate_size=self.intermediate_size						,  hidden_act=self.hidden_act						,  hidden_dropout_prob=self.hidden_dropout_prob						,  attention_probs_dropout_prob=self.attention_probs_dropout_prob						,  max_position_embeddings=self.max_position_embeddings						,  type_vocab_size=self.type_vocab_size						,  initializer_range=self.initializer_range						,  is_folding_model=lowercase						,  esmfold_config={"trunk": {"num_blocks": 2}, "fp16_esm": False}						,  )
					return config



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase						,  lowercase						,  lowercase						,  lowercase						,  lowercase )				->       int:
					lowerCamelCase_						=			EsmForProteinFolding(config=lowercase ).float()
					model.to(lowercase )
					model.eval()
					lowerCamelCase_						=			model(lowercase						,  attention_mask=lowercase )
					lowerCamelCase_						=			model(lowercase )
					lowerCamelCase_						=			model(lowercase )

					self.parent.assertEqual(result.positions.shape						,  (8, self.batch_size, self.seq_length, 14, 3) )
					self.parent.assertEqual(result.angles.shape						,  (8, self.batch_size, self.seq_length, 7, 2) )



	def     SCREAMING_SNAKE_CASE_(    self )				->       Dict:
					lowerCamelCase_						=			self.prepare_config_and_inputs()
					(
					    (
					    lowerCamelCase_
					)	,    (
					    lowerCamelCase_
					)	,    (
					    lowerCamelCase_
					)	,    (
					    lowerCamelCase_
					)	,    (
					    lowerCamelCase_
					)	,    (
					    lowerCamelCase_
					)	,    
					)						=			config_and_inputs
					lowerCamelCase_						=			{"input_ids": input_ids, "attention_mask": input_mask}
					return config, inputs_dict




@require_torch
class     _SCREAMING_SNAKE_CASE     (      snake_case_			,       snake_case_			,       unittest.TestCase						):
	lowerCAmelCase__         = False

	lowerCAmelCase__         = (EsmForProteinFolding,) if is_torch_available() else ()
	lowerCAmelCase__         = ()
	lowerCAmelCase__         = {} if is_torch_available() else {}
	lowerCAmelCase__         = False



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					lowerCamelCase_						=			EsmFoldModelTester(self )
					lowerCamelCase_						=			ConfigTester(self						,  config_class=lowercase						,  hidden_size=37 )



	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					self.config_tester.run_common_tests()



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[int]:
					lowerCamelCase_						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase )



	@unittest.skip("Does not support attention outputs" )
	def     SCREAMING_SNAKE_CASE_(    self )				->       List[str]:
					pass



	@unittest.skip
	def     SCREAMING_SNAKE_CASE_(    self )				->       Dict:
					pass



	@unittest.skip("Esm does not support embedding resizing" )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Union[str, Any]:
					pass



	@unittest.skip("Esm does not support embedding resizing" )
	def     SCREAMING_SNAKE_CASE_(    self )				->       List[Any]:
					pass



	@unittest.skip("ESMFold does not support passing input embeds!" )
	def     SCREAMING_SNAKE_CASE_(    self )				->       List[Any]:
					pass



	@unittest.skip("ESMFold does not support head pruning." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Union[str, Any]:
					pass



	@unittest.skip("ESMFold does not support head pruning." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Any:
					pass



	@unittest.skip("ESMFold does not support head pruning." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Any:
					pass



	@unittest.skip("ESMFold does not support head pruning." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					pass



	@unittest.skip("ESMFold does not support head pruning." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       int:
					pass



	@unittest.skip("ESMFold does not output hidden states in the normal way." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Any:
					pass



	@unittest.skip("ESMfold does not output hidden states in the normal way." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       int:
					pass



	@unittest.skip("ESMFold only has one output format." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Union[str, Any]:
					pass



	@unittest.skip("This test doesn't work for ESMFold and doesn't test core functionality" )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Dict:
					pass



	@unittest.skip("ESMFold does not support input chunking." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					pass



	@unittest.skip("ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Any:
					pass



	@unittest.skip("ESMFold doesn't support torchscript compilation." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					pass



	@unittest.skip("ESMFold doesn't support torchscript compilation." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       List[Any]:
					pass



	@unittest.skip("ESMFold doesn't support torchscript compilation." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					pass



	@unittest.skip("ESMFold doesn't support data parallel." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					pass



	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." )
	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					pass




@require_torch
class     _SCREAMING_SNAKE_CASE     (      snake_case_						):



	@slow
	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					lowerCamelCase_						=			EsmForProteinFolding.from_pretrained("facebook/esmfold_v1" ).float()
					model.eval()
					lowerCamelCase_						=			torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] )
					lowerCamelCase_						=			model(lowercase )["positions"]
					lowerCamelCase_						=			torch.tensor([2.5_8_2_8, 0.7_9_9_3, -1_0.9_3_3_4]						,  dtype=torch.floataa )
					self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]						,  lowercase						,  atol=1e-4 ) )




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				=pytest.mark.integration




@require_faiss
class     _SCREAMING_SNAKE_CASE     (      snake_case_						):



	def     SCREAMING_SNAKE_CASE_(    self )				->       List[str]:
					lowerCamelCase_						=			Dataset.from_dict({"filename": ["my_name-train" + "_" + str(lowercase ) for x in np.arange(30 ).tolist()]} )
					return dset



	def     SCREAMING_SNAKE_CASE_(    self )				->       Union[str, Any]:
					import faiss

					lowerCamelCase_						=			self._create_dummy_dataset()
					lowerCamelCase_						=			dset.map(
					    lambda lowercase						,  lowercase : {"vecs": i * np.ones(5						,  dtype=np.floataa )}						,  with_indices=lowercase						,  keep_in_memory=lowercase )
					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     SCREAMING_SNAKE_CASE_(    self )				->       Dict:
					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     SCREAMING_SNAKE_CASE_(    self )				->       Optional[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"						,  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=lowercase ) 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     SCREAMING_SNAKE_CASE_(    self )				->       Union[str, Any]:
					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(lowercase						,  partial(dset.get_nearest_examples						,  "vecs2"						,  np.ones(5						,  dtype=np.floataa ) ) )



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[int]:
					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=lowercase )
									lowerCamelCase_	,    lowerCamelCase_						=			dset.get_nearest_examples("filename"						,  "my_name-train_29" )
									self.assertEqual(examples["filename"][0]						,  "my_name-train_29" )




@require_faiss
class     _SCREAMING_SNAKE_CASE     (      snake_case_						):



	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					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(lowercase )
					self.assertRaises(lowercase						,  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(lowercase )
					self.assertRaises(lowercase						,  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(lowercase )						,  0 )
					self.assertListEqual([4, 3, 2, 1, 0]						,  lowercase )



	def     SCREAMING_SNAKE_CASE_(    self )				->       Any:
					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(lowercase ):
									lowerCamelCase_						=			FaissIndex(string_factory="Flat"						,  custom_index=faiss.IndexFlat(5 ) )



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[int]:
					import faiss

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



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





@require_faiss
def 			lowerCamelCase_ (				lowerCamelCase__    ):
				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     _SCREAMING_SNAKE_CASE     (      snake_case_						):



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					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=lowercase )
									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(lowercase )
									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(lowercase						,  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(lowercase )
									lowerCamelCase_						=			[scores[0] for scores in total_scores]
									lowerCamelCase_						=			[indices[0] for indices in total_indices]
									self.assertGreater(np.min(lowercase )						,  0 )
									self.assertListEqual([1, 1, 1]						,  lowercase )

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


