




from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
	from PIL import Image

	from transformers import ConvNextImageProcessor

class 		lowercase_       :




					def __init__(   self:		Any,     _lowercase:		Tuple,     _lowercase:		int=13,     _lowercase:		Dict=32,     _lowercase:		Any=3,     _lowercase:		int=4,     _lowercase:		Optional[Any]=[10, 20, 30, 40],     _lowercase:		Any=[2, 2, 3, 2],     _lowercase:		Optional[int]=True,     _lowercase:		List[Any]=True,     _lowercase:		List[Any]=37,     _lowercase:		List[str]="gelu",     _lowercase:		List[str]=10,     _lowercase:		Any=0.02,     _lowercase:		int=3,     _lowercase:		List[str]=None,     ):


									'''simple docstring'''


									__lowerCAmelCase					=  parent
									__lowerCAmelCase					=  batch_size
									__lowerCAmelCase					=  image_size
									__lowerCAmelCase					=  num_channels
									__lowerCAmelCase					=  num_stages
									__lowerCAmelCase					=  hidden_sizes
									__lowerCAmelCase					=  depths
									__lowerCAmelCase					=  is_training
									__lowerCAmelCase					=  use_labels
									__lowerCAmelCase					=  intermediate_size
									__lowerCAmelCase					=  hidden_act
									__lowerCAmelCase					=  type_sequence_label_size
									__lowerCAmelCase					=  initializer_range
									__lowerCAmelCase					=  scope




					def     _lowercase						(   self:		Optional[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

									__lowerCAmelCase					=  None
									if self.use_labels:
													__lowerCAmelCase					=  ids_tensor([self.batch_size],     self.type_sequence_label_size)

									__lowerCAmelCase					=  self.get_config()

									return config, pixel_values, labels




					def     _lowercase						(   self:		int):


									'''simple docstring'''


									return ConvNextConfig(
									    num_channels=self.num_channels,     hidden_sizes=self.hidden_sizes,     depths=self.depths,     num_stages=self.num_stages,     hidden_act=self.hidden_act,     is_decoder=_lowercase,     initializer_range=self.initializer_range,     )




					def     _lowercase						(   self:		Optional[Any],     _lowercase:		List[Any],     _lowercase:		Optional[Any],     _lowercase:		int):


									'''simple docstring'''


									__lowerCAmelCase					=  TFConvNextModel(config=_lowercase)
									__lowerCAmelCase					=  model(_lowercase,     training=_lowercase)
									# expected last hidden states: B, C, H // 32, W // 32
									self.parent.assertEqual(
									    result.last_hidden_state.shape,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32),     )




					def     _lowercase						(   self:		Optional[Any],     _lowercase:		int,     _lowercase:		int,     _lowercase:		int):


									'''simple docstring'''


									__lowerCAmelCase					=  self.type_sequence_label_size
									__lowerCAmelCase					=  TFConvNextForImageClassification(_lowercase)
									__lowerCAmelCase					=  model(_lowercase,     labels=_lowercase,     training=_lowercase)
									self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.type_sequence_label_size))







					def     _lowercase						(   self:		Union[str, Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  self.prepare_config_and_inputs()
									__lowerCAmelCase	,				__lowerCAmelCase	,				__lowerCAmelCase					=  config_and_inputs
									__lowerCAmelCase					=  {"""pixel_values""": pixel_values}
									return config, inputs_dict





@require_tf
class 		lowercase_       (	lowerCAmelCase__						,							lowerCAmelCase__						,							unittest.TestCase				):
					__UpperCamelCase     	= (TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
					__UpperCamelCase     	= (
					    {"feature-extraction": TFConvNextModel, "image-classification": TFConvNextForImageClassification}
					    if is_tf_available()
					    else {}
					)

					__UpperCamelCase     	= False
					__UpperCamelCase     	= False
					__UpperCamelCase     	= False
					__UpperCamelCase     	= False
					__UpperCamelCase     	= False




					def     _lowercase						(   self:		Tuple):


									'''simple docstring'''


									__lowerCAmelCase					=  TFConvNextModelTester(self)
									__lowerCAmelCase					=  ConfigTester(
									    self,     config_class=_lowercase,     has_text_modality=_lowercase,     hidden_size=37,     )




					@unittest.skip(reason="""ConvNext does not use inputs_embeds""")
					def     _lowercase						(   self:		Any):


									'''simple docstring'''


									pass




					@unittest.skipIf(
					    not is_tf_available() or len(tf.config.list_physical_devices("""GPU""")) == 0,     reason="""TF does not support backprop for grouped convolutions on CPU.""",     )
					@slow
					def     _lowercase						(   self:		List[Any]):


									'''simple docstring'''


									super().test_keras_fit()




					@unittest.skip(reason="""ConvNext does not support input and output embeddings""")
					def     _lowercase						(   self:		List[Any]):


									'''simple docstring'''


									pass




					def     _lowercase						(   self:		Dict):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													__lowerCAmelCase					=  model_class(_lowercase)
													__lowerCAmelCase					=  inspect.signature(model.call)
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													__lowerCAmelCase					=  [*signature.parameters.keys()]

													__lowerCAmelCase					=  ["""pixel_values"""]
													self.assertListEqual(arg_names[:1],     _lowercase)




					def     _lowercase						(   self:		List[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_lowercase)




					@unittest.skipIf(
					    not is_tf_available() or len(tf.config.list_physical_devices("""GPU""")) == 0,     reason="""TF does not support backprop for grouped convolutions on CPU.""",     )
					def     _lowercase						(   self:		int):


									'''simple docstring'''


									super().test_dataset_conversion()




					def     _lowercase						(   self:		int):


									'''simple docstring'''


									def check_hidden_states_output(_lowercase:		Any,     _lowercase:		Dict,     _lowercase:		Any):
													__lowerCAmelCase					=  model_class(_lowercase)

													__lowerCAmelCase					=  model(**self._prepare_for_class(_lowercase,     _lowercase))
													__lowerCAmelCase					=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__lowerCAmelCase					=  self.model_tester.num_stages
													self.assertEqual(len(_lowercase),     expected_num_stages + 1)

													# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]),     [self.model_tester.image_size // 4, self.model_tester.image_size // 4],     )

									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													__lowerCAmelCase					=  True
													check_hidden_states_output(_lowercase,     _lowercase,     _lowercase)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													__lowerCAmelCase					=  True

													check_hidden_states_output(_lowercase,     _lowercase,     _lowercase)




					def     _lowercase						(   self:		Optional[Any]):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

									def check_equivalence(_lowercase:		Tuple,     _lowercase:		Tuple,     _lowercase:		str,     _lowercase:		Dict={}):
													__lowerCAmelCase					=  model(_lowercase,     return_dict=_lowercase,     **_lowercase)
													__lowerCAmelCase					=  model(_lowercase,     return_dict=_lowercase,     **_lowercase).to_tuple()

													def recursive_check(_lowercase:		Union[str, Any],     _lowercase:		List[str]):
																	if isinstance(_lowercase,     (List, Tuple)):
																					for tuple_iterable_value, dict_iterable_value in zip(_lowercase,     _lowercase):
																									recursive_check(_lowercase,     _lowercase)
																	elif tuple_object is None:
																					return
																	else:
																					self.assertTrue(
																					    all(tf.equal(_lowercase,     _lowercase)),     msg=(
																					        """Tuple and dict output are not equal. Difference:"""
																					        f''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object))}'''
																					    ),     )

																	recursive_check(_lowercase,     _lowercase)

									for model_class in self.all_model_classes:
													__lowerCAmelCase					=  model_class(_lowercase)

													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase)
													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase)
													check_equivalence(_lowercase,     _lowercase,     _lowercase)

													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase,     return_labels=_lowercase)
													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase,     return_labels=_lowercase)
													check_equivalence(_lowercase,     _lowercase,     _lowercase)

													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase)
													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase)
													check_equivalence(_lowercase,     _lowercase,     _lowercase,     {"""output_hidden_states""": True})

													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase,     return_labels=_lowercase)
													__lowerCAmelCase					=  self._prepare_for_class(_lowercase,     _lowercase,     return_labels=_lowercase)
													check_equivalence(_lowercase,     _lowercase,     _lowercase,     {"""output_hidden_states""": True})




					def     _lowercase						(   self:		List[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_lowercase)







					@slow
					def     _lowercase						(   self:		Dict):


									'''simple docstring'''


									__lowerCAmelCase					=  TFConvNextModel.from_pretrained("""facebook/convnext-tiny-224""")
									self.assertIsNotNone(_lowercase)





def      UpperCAmelCase  (						)     ->     Any:







				'''simple docstring'''


				__lowerCAmelCase					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
				return image

@require_tf
@require_vision
class 		lowercase_       (	unittest.TestCase				):




					@cached_property
					def     _lowercase						(   self:		int):


									'''simple docstring'''


									return ConvNextImageProcessor.from_pretrained("""facebook/convnext-tiny-224""") if is_vision_available() else None







					@slow
					def     _lowercase						(   self:		Union[str, Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  TFConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224""")

									__lowerCAmelCase					=  self.default_image_processor
									__lowerCAmelCase					=  prepare_img()
									__lowerCAmelCase					=  image_processor(images=_lowercase,     return_tensors="""tf""")

									# forward pass
									__lowerCAmelCase					=  model(**_lowercase)

									# verify the logits
									__lowerCAmelCase					=  tf.TensorShape((1, 1000))
									self.assertEqual(outputs.logits.shape,     _lowercase)

									__lowerCAmelCase					=  tf.constant([-0.0_260, -0.4_739, 0.1_911])

									tf.debugging.assert_near(outputs.logits[0, :3],     _lowercase,     atol=1e-4)











import json
import os
import shutil
import sys
import tempfile
import unittest
from unittest import TestCase
from unittest.mock import patch

import faiss
import numpy as np
from datasets import Dataset

from transformers import BartConfig, BartTokenizer, DPRConfig, DPRQuestionEncoderTokenizer, RagConfig
from transformers.file_utils import is_datasets_available, is_faiss_available, is_psutil_available, is_torch_available
from transformers.integrations import is_ray_available
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_ray


sys.path.append(os.path.join(os.getcwd()))  # noqa: E402 # noqa: E402 # isort:skip

if is_torch_available():
	from distributed_pytorch_retriever import RagPyTorchDistributedRetriever  # noqa: E402 # isort:skip
else:
	__A						:		str          =						None

if is_ray_available():
	import ray  # noqa: E402 # isort:skip
	from distributed_ray_retriever import RagRayDistributedRetriever, RayRetriever  # noqa: E402 # isort:skip
else:
	__A						:		int          =						None
	__A						:		Tuple          =						None
	__A						:		Union[str, Any]          =						None





def      UpperCAmelCase  (						UpperCamelCase__   )     ->     Union[str, Any]:







				'''simple docstring'''


				if not (is_datasets_available() and is_faiss_available() and is_psutil_available()):
								__lowerCAmelCase					=  unittest.skip("""test requires Datasets, Faiss, psutil"""   )(UpperCamelCase__   )
				return test_case

@require_distributed_retrieval
class 		lowercase_       (	lowerCAmelCase__				):




					def     _lowercase						(   self:		List[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  tempfile.mkdtemp()
									__lowerCAmelCase					=  8

									# DPR tok
									__lowerCAmelCase					=  [
									    """[UNK]""",
									    """[CLS]""",
									    """[SEP]""",
									    """[PAD]""",
									    """[MASK]""",
									    """want""",
									    """##want""",
									    """##ed""",
									    """wa""",
									    """un""",
									    """runn""",
									    """##ing""",
									    """,""",
									    """low""",
									    """lowest""",
									]
									__lowerCAmelCase					=  os.path.join(self.tmpdirname,     """dpr_tokenizer""")
									os.makedirs(_lowercase,     exist_ok=_lowercase)
									__lowerCAmelCase					=  os.path.join(_lowercase,     DPR_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]))

									# BART tok
									__lowerCAmelCase					=  [
									    """l""",
									    """o""",
									    """w""",
									    """e""",
									    """r""",
									    """s""",
									    """t""",
									    """i""",
									    """d""",
									    """n""",
									    """\u0120""",
									    """\u0120l""",
									    """\u0120n""",
									    """\u0120lo""",
									    """\u0120low""",
									    """er""",
									    """\u0120lowest""",
									    """\u0120newer""",
									    """\u0120wider""",
									    """<unk>""",
									]
									__lowerCAmelCase					=  dict(zip(_lowercase,     range(len(_lowercase))))
									__lowerCAmelCase					=  ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
									__lowerCAmelCase					=  {"""unk_token""": """<unk>"""}

									__lowerCAmelCase					=  os.path.join(self.tmpdirname,     """bart_tokenizer""")
									os.makedirs(_lowercase,     exist_ok=_lowercase)
									__lowerCAmelCase					=  os.path.join(_lowercase,     BART_VOCAB_FILES_NAMES["""vocab_file"""])
									__lowerCAmelCase					=  os.path.join(_lowercase,     BART_VOCAB_FILES_NAMES["""merges_file"""])
									with open(self.vocab_file,     """w""",     encoding="""utf-8""") as fp:
													fp.write(json.dumps(_lowercase) + """\n""")
									with open(self.merges_file,     """w""",     encoding="""utf-8""") as fp:
													fp.write("""\n""".join(_lowercase))




					def     _lowercase						(   self:		Optional[Any]):


									'''simple docstring'''


									return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname,     """dpr_tokenizer"""))




					def     _lowercase						(   self:		int):


									'''simple docstring'''


									return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname,     """bart_tokenizer"""))




					def     _lowercase						(   self:		Optional[int]):


									'''simple docstring'''


									shutil.rmtree(self.tmpdirname)




					def     _lowercase						(   self:		Tuple):


									'''simple docstring'''


									__lowerCAmelCase					=  Dataset.from_dict(
									    {
									        """id""": ["""0""", """1"""],
									        """text""": ["""foo""", """bar"""],
									        """title""": ["""Foo""", """Bar"""],
									        """embeddings""": [np.ones(self.retrieval_vector_size), 2 * np.ones(self.retrieval_vector_size)],
									    })
									dataset.add_faiss_index("""embeddings""",     string_factory="""Flat""",     metric_type=faiss.METRIC_INNER_PRODUCT)
									return dataset




					def     _lowercase						(   self:		Union[str, Any],     _lowercase:		bool,     _lowercase:		Any=12345):


									'''simple docstring'''


									__lowerCAmelCase					=  self.get_dummy_dataset()
									__lowerCAmelCase					=  RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size,     question_encoder=DPRConfig().to_dict(),     generator=BartConfig().to_dict(),     )
									with patch("""transformers.models.rag.retrieval_rag.load_dataset""") as mock_load_dataset:
													__lowerCAmelCase					=  dataset
													__lowerCAmelCase					=  RagPyTorchDistributedRetriever(
													    _lowercase,     question_encoder_tokenizer=self.get_dpr_tokenizer(),     generator_tokenizer=self.get_bart_tokenizer(),     )
													if init_retrieval:
																	retriever.init_retrieval(_lowercase)
									return retriever




					def     _lowercase						(   self:		Union[str, Any],     _lowercase:		bool):


									'''simple docstring'''


									ray.init(local_mode=_lowercase)
									__lowerCAmelCase					=  RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size,     question_encoder=DPRConfig().to_dict(),     generator=BartConfig().to_dict(),     )
									__lowerCAmelCase					=  ray.remote(_lowercase)
									__lowerCAmelCase					=  [remote_cls.remote() for _ in range(1)]
									with patch("""transformers.models.rag.retrieval_rag.load_dataset""") as mock_load_dataset:
													__lowerCAmelCase					=  self.get_dummy_dataset()
													__lowerCAmelCase					=  RagRayDistributedRetriever(
													    _lowercase,     question_encoder_tokenizer=self.get_dpr_tokenizer(),     generator_tokenizer=self.get_bart_tokenizer(),     retrieval_workers=_lowercase,     )
													if init_retrieval:
																	retriever.init_retrieval()
									return retriever




					def     _lowercase						(   self:		Optional[Any],     _lowercase:		bool,     _lowercase:		bool,     _lowercase:		int=12345):


									'''simple docstring'''


									__lowerCAmelCase					=  self.get_dummy_dataset()
									__lowerCAmelCase					=  RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size,     question_encoder=DPRConfig().to_dict(),     generator=BartConfig().to_dict(),     index_name="""custom""",     )
									if from_disk:
													__lowerCAmelCase					=  os.path.join(self.tmpdirname,     """dataset""")
													__lowerCAmelCase					=  os.path.join(self.tmpdirname,     """index.faiss""")
													dataset.get_index("""embeddings""").save(os.path.join(self.tmpdirname,     """index.faiss"""))
													dataset.drop_index("""embeddings""")
													dataset.save_to_disk(os.path.join(self.tmpdirname,     """dataset"""))
													del dataset
													__lowerCAmelCase					=  RagPyTorchDistributedRetriever(
													    _lowercase,     question_encoder_tokenizer=self.get_dpr_tokenizer(),     generator_tokenizer=self.get_bart_tokenizer(),     )
									else:
													__lowerCAmelCase					=  RagPyTorchDistributedRetriever(
													    _lowercase,     question_encoder_tokenizer=self.get_dpr_tokenizer(),     generator_tokenizer=self.get_bart_tokenizer(),     index=CustomHFIndex(config.retrieval_vector_size,     _lowercase),     )
									if init_retrieval:
													retriever.init_retrieval(_lowercase)
									return retriever




					def     _lowercase						(   self:		List[Any],     _lowercase:		bool,     _lowercase:		bool):


									'''simple docstring'''


									ray.init(local_mode=_lowercase)
									__lowerCAmelCase					=  self.get_dummy_dataset()
									__lowerCAmelCase					=  RagConfig(
									    retrieval_vector_size=self.retrieval_vector_size,     question_encoder=DPRConfig().to_dict(),     generator=BartConfig().to_dict(),     index_name="""custom""",     )
									__lowerCAmelCase					=  ray.remote(_lowercase)
									__lowerCAmelCase					=  [remote_cls.remote() for _ in range(1)]
									if from_disk:
													__lowerCAmelCase					=  os.path.join(self.tmpdirname,     """dataset""")
													__lowerCAmelCase					=  os.path.join(self.tmpdirname,     """index.faiss""")
													dataset.get_index("""embeddings""").save(os.path.join(self.tmpdirname,     """index.faiss"""))
													dataset.drop_index("""embeddings""")
													dataset.save_to_disk(os.path.join(self.tmpdirname,     """dataset"""))
													del dataset
													__lowerCAmelCase					=  RagRayDistributedRetriever(
													    _lowercase,     question_encoder_tokenizer=self.get_dpr_tokenizer(),     generator_tokenizer=self.get_bart_tokenizer(),     retrieval_workers=_lowercase,     index=CustomHFIndex.load_from_disk(
													        vector_size=config.retrieval_vector_size,     dataset_path=config.passages_path,     index_path=config.index_path,     ),     )
									else:
													__lowerCAmelCase					=  RagRayDistributedRetriever(
													    _lowercase,     question_encoder_tokenizer=self.get_dpr_tokenizer(),     generator_tokenizer=self.get_bart_tokenizer(),     retrieval_workers=_lowercase,     index=CustomHFIndex(config.retrieval_vector_size,     _lowercase),     )
									if init_retrieval:
													retriever.init_retrieval()
									return retriever




					def     _lowercase						(   self:		int,     _lowercase:		RagRetriever,     _lowercase:		np.array,     _lowercase:		int):


									'''simple docstring'''


									__lowerCAmelCase	,				__lowerCAmelCase	,				__lowerCAmelCase					=  retriever.retrieve(_lowercase,     n_docs=_lowercase)
									self.assertEqual(retrieved_doc_embeds.shape,     (2, n_docs, self.retrieval_vector_size))
									self.assertEqual(len(_lowercase),     2)
									self.assertEqual(sorted(doc_dicts[0]),     ["""embeddings""", """id""", """text""", """title"""])
									self.assertEqual(len(doc_dicts[0]["""id"""]),     _lowercase)
									self.assertEqual(doc_dicts[0]["""id"""][0],     """1""")  # max inner product is reached with second doc
									self.assertEqual(doc_dicts[1]["""id"""][0],     """0""")  # max inner product is reached with first doc
									self.assertListEqual(doc_ids.tolist(),     [[1], [0]])




					def     _lowercase						(   self:		Optional[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  1
									__lowerCAmelCase					=  np.array(
									    [np.ones(self.retrieval_vector_size), -np.ones(self.retrieval_vector_size)],     dtype=np.floataa)

									self.distributed_retriever_check(
									    self.get_dummy_pytorch_distributed_retriever(init_retrieval=_lowercase),     _lowercase,     _lowercase)




					def     _lowercase						(   self:		int):


									'''simple docstring'''


									__lowerCAmelCase					=  1
									__lowerCAmelCase					=  np.array(
									    [np.ones(self.retrieval_vector_size), -np.ones(self.retrieval_vector_size)],     dtype=np.floataa)

									self.distributed_retriever_check(
									    self.get_dummy_custom_hf_index_pytorch_retriever(init_retrieval=_lowercase,     from_disk=_lowercase),     _lowercase,     _lowercase,     )




					def     _lowercase						(   self:		Dict):


									'''simple docstring'''


									__lowerCAmelCase					=  1
									__lowerCAmelCase					=  np.array(
									    [np.ones(self.retrieval_vector_size), -np.ones(self.retrieval_vector_size)],     dtype=np.floataa)

									self.distributed_retriever_check(
									    self.get_dummy_custom_hf_index_pytorch_retriever(init_retrieval=_lowercase,     from_disk=_lowercase),     _lowercase,     _lowercase,     )




					@require_ray
					def     _lowercase						(   self:		List[str]):


									'''simple docstring'''


									__lowerCAmelCase					=  1
									__lowerCAmelCase					=  np.array(
									    [np.ones(self.retrieval_vector_size), -np.ones(self.retrieval_vector_size)],     dtype=np.floataa)

									self.distributed_retriever_check(
									    self.get_dummy_ray_distributed_retriever(init_retrieval=_lowercase),     _lowercase,     _lowercase)
									ray.shutdown()




					@require_ray
					def     _lowercase						(   self:		Union[str, Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  1
									__lowerCAmelCase					=  np.array(
									    [np.ones(self.retrieval_vector_size), -np.ones(self.retrieval_vector_size)],     dtype=np.floataa)
									with self.assertRaises(_lowercase):
													self.distributed_retriever_check(
													    self.get_dummy_custom_hf_index_ray_retriever(init_retrieval=_lowercase,     from_disk=_lowercase),     _lowercase,     _lowercase,     )
									ray.shutdown()







					@require_ray
					def     _lowercase						(   self:		Tuple):


									'''simple docstring'''


									__lowerCAmelCase					=  1
									__lowerCAmelCase					=  np.array(
									    [np.ones(self.retrieval_vector_size), -np.ones(self.retrieval_vector_size)],     dtype=np.floataa)

									self.distributed_retriever_check(
									    self.get_dummy_custom_hf_index_ray_retriever(init_retrieval=_lowercase,     from_disk=_lowercase),     _lowercase,     _lowercase)
									ray.shutdown()





