

class        a__       :







  """simple docstring"""




  def __init__(			self    : Union[str, Any]		)					->Any:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Tuple       =   """"""
        SCREAMING_SNAKE_CASE :      Dict       =   """"""
        SCREAMING_SNAKE_CASE :      List[Any]       =   []


  def  _lowercase      (			self    : List[str]				,				UpperCAmelCase__    : int				,				UpperCAmelCase__    : int		)					->int:
        """simple docstring"""







        if m == -1:
              return n + 1
        elif n == -1:
              return m + 1
        elif self.dp[m][n] > -1:
              return self.dp[m][n]
        else:
              if self.worda[m] == self.worda[n]:
                    SCREAMING_SNAKE_CASE :      List[str]       =   self.__min_dist_top_down_dp(m - 1				,				n - 1		)
              else:
                    SCREAMING_SNAKE_CASE :      List[Any]       =   self.__min_dist_top_down_dp(UpperCAmelCase__				,				n - 1		)
                    SCREAMING_SNAKE_CASE :      List[Any]       =   self.__min_dist_top_down_dp(m - 1				,				UpperCAmelCase__		)
                    SCREAMING_SNAKE_CASE :      List[str]       =   self.__min_dist_top_down_dp(m - 1				,				n - 1		)
                    SCREAMING_SNAKE_CASE :      List[Any]       =   1 + min(UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__		)

              return self.dp[m][n]


  def  _lowercase      (			self    : Tuple				,				UpperCAmelCase__    : str				,				UpperCAmelCase__    : str		)					->int:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[Any]       =   worda
        SCREAMING_SNAKE_CASE :      int       =   worda
        SCREAMING_SNAKE_CASE :      str       =   [[-1 for _ in range(len(UpperCAmelCase__		)		)] for _ in range(len(UpperCAmelCase__		)		)]

        return self.__min_dist_top_down_dp(len(UpperCAmelCase__		) - 1				,				len(UpperCAmelCase__		) - 1		)




  def  _lowercase      (			self    : str				,				UpperCAmelCase__    : str				,				UpperCAmelCase__    : str		)					->int:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Tuple       =   worda
        SCREAMING_SNAKE_CASE :      Dict       =   worda
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   len(UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Tuple       =   len(UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Any       =   [[0 for _ in range(n + 1		)] for _ in range(m + 1		)]

        for i in range(m + 1		):
              for j in range(n + 1		):
                    if i == 0:  # first string is empty
                          SCREAMING_SNAKE_CASE :      List[Any]       =   j
                    elif j == 0:  # second string is empty
                          SCREAMING_SNAKE_CASE :      Optional[int]       =   i
                    elif worda[i - 1] == worda[j - 1]:  # last characters are equal
                          SCREAMING_SNAKE_CASE :      List[Any]       =   self.dp[i - 1][j - 1]
                    else:
                          SCREAMING_SNAKE_CASE :      Dict       =   self.dp[i][j - 1]
                          SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.dp[i - 1][j]
                          SCREAMING_SNAKE_CASE :      List[str]       =   self.dp[i - 1][j - 1]
                          SCREAMING_SNAKE_CASE :      Union[str, Any]       =   1 + min(UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__		)
        return self.dp[m][n]


if __name__ == "__main__":
  UpperCAmelCase__ :     str				    =    EditDistance()

  print("""****************** Testing Edit Distance DP Algorithm ******************""")
  print()

  UpperCAmelCase__ :     str				    =    input("""Enter the first string: """).strip()
  UpperCAmelCase__ :     str				    =    input("""Enter the second string: """).strip()

  print()
  print(F"""The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}""")
  print(F"""The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}""")
  print()
  print("""*************** End of Testing Edit Distance DP Algorithm ***************""")







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

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
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_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
  import faiss







@require_faiss
class        a__       (   UpperCAmelCase       ):







  """simple docstring"""




  def  _lowercase      (			self    : Optional[int]		)					->Optional[int]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[Any]       =   tempfile.mkdtemp()
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   8

        # DPR tok
        SCREAMING_SNAKE_CASE :      List[str]       =   [
            """[UNK]""",
            """[CLS]""",
            """[SEP]""",
            """[PAD]""",
            """[MASK]""",
            """want""",
            """##want""",
            """##ed""",
            """wa""",
            """un""",
            """runn""",
            """##ing""",
            """,""",
            """low""",
            """lowest""",
        ]
        SCREAMING_SNAKE_CASE :      Any       =   os.path.join(self.tmpdirname				,				"""dpr_tokenizer"""		)
        os.makedirs(UpperCAmelCase__				,				exist_ok=UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Any       =   os.path.join(UpperCAmelCase__				,				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
        SCREAMING_SNAKE_CASE :      List[str]       =   [
            """l""",
            """o""",
            """w""",
            """e""",
            """r""",
            """s""",
            """t""",
            """i""",
            """d""",
            """n""",
            """\u0120""",
            """\u0120l""",
            """\u0120n""",
            """\u0120lo""",
            """\u0120low""",
            """er""",
            """\u0120lowest""",
            """\u0120newer""",
            """\u0120wider""",
            """<unk>""",
        ]
        SCREAMING_SNAKE_CASE :      List[Any]       =   dict(zip(UpperCAmelCase__				,				range(len(UpperCAmelCase__		)		)		)		)
        SCREAMING_SNAKE_CASE :      Dict       =   ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
        SCREAMING_SNAKE_CASE :      List[Any]       =   {"""unk_token""": """<unk>"""}

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


  def  _lowercase      (			self    : Optional[Any]		)					->DPRQuestionEncoderTokenizer:
        """simple docstring"""







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


  def  _lowercase      (			self    : Optional[Any]		)					->DPRContextEncoderTokenizer:
        """simple docstring"""







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


  def  _lowercase      (			self    : Optional[int]		)					->BartTokenizer:
        """simple docstring"""







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


  def  _lowercase      (			self    : Any		)					->List[str]:
        """simple docstring"""







        shutil.rmtree(self.tmpdirname		)


  def  _lowercase      (			self    : Tuple		)					->Union[str, Any]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      str       =   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]		)					->Tuple:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      int       =   self.get_dummy_dataset()
        SCREAMING_SNAKE_CASE :      str       =   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:
              SCREAMING_SNAKE_CASE :      Tuple       =   dataset
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   RagRetriever(
                  UpperCAmelCase__				,				question_encoder_tokenizer=self.get_dpr_tokenizer()				,				generator_tokenizer=self.get_bart_tokenizer()				,				)
        return retriever


  def  _lowercase      (			self    : List[Any]				,				UpperCAmelCase__    : bool		)					->Union[str, Any]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Any       =   self.get_dummy_dataset()
        SCREAMING_SNAKE_CASE :      Dict       =   RagConfig(
            retrieval_vector_size=self.retrieval_vector_size				,				question_encoder=DPRConfig().to_dict()				,				generator=BartConfig().to_dict()				,				index_name="""custom"""				,				)
        if from_disk:
              SCREAMING_SNAKE_CASE :      List[str]       =   os.path.join(self.tmpdirname				,				"""dataset"""		)
              SCREAMING_SNAKE_CASE :      Any       =   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
              SCREAMING_SNAKE_CASE :      Any       =   RagRetriever(
                  UpperCAmelCase__				,				question_encoder_tokenizer=self.get_dpr_tokenizer()				,				generator_tokenizer=self.get_bart_tokenizer()				,				)
        else:
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   RagRetriever(
                  UpperCAmelCase__				,				question_encoder_tokenizer=self.get_dpr_tokenizer()				,				generator_tokenizer=self.get_bart_tokenizer()				,				index=CustomHFIndex(config.retrieval_vector_size				,				UpperCAmelCase__		)				,				)
        return retriever


  def  _lowercase      (			self    : int		)					->int:
        """simple docstring"""







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

        SCREAMING_SNAKE_CASE :      Any       =   os.path.join(self.tmpdirname				,				"""hf_bert_base.hnswSQ8_correct_phi_128.c_index"""		)
        dataset.save_faiss_index("""embeddings"""				,				index_file_name + """.index.dpr"""		)
        pickle.dump(dataset["""id"""]				,				open(index_file_name + """.index_meta.dpr"""				,				"""wb"""		)		)

        SCREAMING_SNAKE_CASE :      Optional[Any]       =   os.path.join(self.tmpdirname				,				"""psgs_w100.tsv.pkl"""		)
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   {sample["""id"""]: [sample["""text"""], sample["""title"""]] for sample in dataset}
        pickle.dump(UpperCAmelCase__				,				open(UpperCAmelCase__				,				"""wb"""		)		)

        SCREAMING_SNAKE_CASE :      str       =   RagConfig(
            retrieval_vector_size=self.retrieval_vector_size				,				question_encoder=DPRConfig().to_dict()				,				generator=BartConfig().to_dict()				,				index_name="""legacy"""				,				index_path=self.tmpdirname				,				)
        SCREAMING_SNAKE_CASE :      Any       =   RagRetriever(
            UpperCAmelCase__				,				question_encoder_tokenizer=self.get_dpr_tokenizer()				,				generator_tokenizer=self.get_bart_tokenizer()		)
        return retriever


  def  _lowercase      (			self    : Dict		)					->Optional[int]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Any       =   1
        SCREAMING_SNAKE_CASE :      str       =   self.get_dummy_canonical_hf_index_retriever()
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   np.array(
            [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      Union[str, Any]       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=UpperCAmelCase__		)
        self.assertEqual(retrieved_doc_embeds.shape				,				(2, n_docs, self.retrieval_vector_size)		)
        self.assertEqual(len(UpperCAmelCase__		)				,				2		)
        self.assertEqual(sorted(doc_dicts[0]		)				,				["""embeddings""", """id""", """text""", """title"""]		)
        self.assertEqual(len(doc_dicts[0]["""id"""]		)				,				UpperCAmelCase__		)
        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    : List[str]		)					->int:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Optional[Any]       =   self.get_dummy_canonical_hf_index_retriever()
        with tempfile.TemporaryDirectory() as tmp_dirname:
              with patch("""transformers.models.rag.retrieval_rag.load_dataset"""		) as mock_load_dataset:
                    SCREAMING_SNAKE_CASE :      Optional[int]       =   self.get_dummy_dataset()
                    retriever.save_pretrained(UpperCAmelCase__		)
                    SCREAMING_SNAKE_CASE :      List[Any]       =   RagRetriever.from_pretrained(UpperCAmelCase__		)
                    self.assertIsInstance(UpperCAmelCase__				,				UpperCAmelCase__		)
                    SCREAMING_SNAKE_CASE :      Union[str, Any]       =   np.array(
                        [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
                    SCREAMING_SNAKE_CASE :      Dict       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=1		)
                    self.assertTrue(out is not None		)


  def  _lowercase      (			self    : List[Any]		)					->List[str]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Tuple       =   1
        SCREAMING_SNAKE_CASE :      str       =   self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      str       =   np.array(
            [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      List[str]       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=UpperCAmelCase__		)
        self.assertEqual(retrieved_doc_embeds.shape				,				(2, n_docs, self.retrieval_vector_size)		)
        self.assertEqual(len(UpperCAmelCase__		)				,				2		)
        self.assertEqual(sorted(doc_dicts[0]		)				,				["""embeddings""", """id""", """text""", """title"""]		)
        self.assertEqual(len(doc_dicts[0]["""id"""]		)				,				UpperCAmelCase__		)
        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[int]		)					->Optional[Any]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[str]       =   self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase__		)
        with tempfile.TemporaryDirectory() as tmp_dirname:
              retriever.save_pretrained(UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   RagRetriever.from_pretrained(UpperCAmelCase__		)
              self.assertIsInstance(UpperCAmelCase__				,				UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   np.array(
                  [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
              SCREAMING_SNAKE_CASE :      int       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=1		)
              self.assertTrue(out is not None		)


  def  _lowercase      (			self    : Dict		)					->Tuple:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Any       =   1
        SCREAMING_SNAKE_CASE :      List[str]       =   self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   np.array(
            [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      List[Any]       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=UpperCAmelCase__		)
        self.assertEqual(retrieved_doc_embeds.shape				,				(2, n_docs, self.retrieval_vector_size)		)
        self.assertEqual(len(UpperCAmelCase__		)				,				2		)
        self.assertEqual(sorted(doc_dicts[0]		)				,				["""embeddings""", """id""", """text""", """title"""]		)
        self.assertEqual(len(doc_dicts[0]["""id"""]		)				,				UpperCAmelCase__		)
        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    : Union[str, Any]		)					->Any:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Dict       =   self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase__		)
        with tempfile.TemporaryDirectory() as tmp_dirname:
              retriever.save_pretrained(UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      str       =   RagRetriever.from_pretrained(UpperCAmelCase__		)
              self.assertIsInstance(UpperCAmelCase__				,				UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      Optional[int]       =   np.array(
                  [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=1		)
              self.assertTrue(out is not None		)


  def  _lowercase      (			self    : Tuple		)					->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Tuple       =   1
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.get_dummy_legacy_index_retriever()
        SCREAMING_SNAKE_CASE :      int       =   np.array(
            [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      List[Any]       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=UpperCAmelCase__		)
        self.assertEqual(retrieved_doc_embeds.shape				,				(2, n_docs, self.retrieval_vector_size)		)
        self.assertEqual(len(UpperCAmelCase__		)				,				2		)
        self.assertEqual(sorted(doc_dicts[0]		)				,				["""text""", """title"""]		)
        self.assertEqual(len(doc_dicts[0]["""text"""]		)				,				UpperCAmelCase__		)
        self.assertEqual(doc_dicts[0]["""text"""][0]				,				"""bar"""		)  # max inner product is reached with second doc
        self.assertEqual(doc_dicts[1]["""text"""][0]				,				"""foo"""		)  # max inner product is reached with first doc
        self.assertListEqual(doc_ids.tolist()				,				[[1], [0]]		)


  def  _lowercase      (			self    : Any		)					->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Optional[Any]       =   self.get_dummy_legacy_index_retriever()
        with tempfile.TemporaryDirectory() as tmp_dirname:
              retriever.save_pretrained(UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   RagRetriever.from_pretrained(UpperCAmelCase__		)
              self.assertIsInstance(UpperCAmelCase__				,				UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      str       =   np.array(
                  [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
              SCREAMING_SNAKE_CASE :      Dict       =   retriever.retrieve(UpperCAmelCase__				,				n_docs=1		)
              self.assertTrue(out is not None		)


  @require_torch
  @require_tokenizers
  @require_sentencepiece
  def  _lowercase      (			self    : Tuple		)					->Tuple:
        """simple docstring"""







        import torch

        SCREAMING_SNAKE_CASE :      int       =   1
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   self.get_dummy_canonical_hf_index_retriever()
        SCREAMING_SNAKE_CASE :      str       =   [[5, 7], [1_0, 1_1]]
        SCREAMING_SNAKE_CASE :      Tuple       =   np.array(
            [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
        SCREAMING_SNAKE_CASE :      int       =   retriever(UpperCAmelCase__				,				UpperCAmelCase__				,				prefix=retriever.config.generator.prefix				,				n_docs=UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      List[Any]       =   (
            out["""context_input_ids"""],
            out["""context_attention_mask"""],
            out["""retrieved_doc_embeds"""],
        )
        self.assertEqual(retrieved_doc_embeds.shape				,				(2, n_docs, self.retrieval_vector_size)		)
        self.assertIsInstance(UpperCAmelCase__				,				UpperCAmelCase__		)
        self.assertIsInstance(UpperCAmelCase__				,				UpperCAmelCase__		)
        self.assertIsInstance(UpperCAmelCase__				,				np.ndarray		)

        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   retriever(
            UpperCAmelCase__				,				UpperCAmelCase__				,				prefix=retriever.config.generator.prefix				,				n_docs=UpperCAmelCase__				,				return_tensors="""pt"""				,				)
        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      Union[str, Any]       =   (  # noqa: F841
            out["""context_input_ids"""],
            out["""context_attention_mask"""],
            out["""retrieved_doc_embeds"""],
            out["""doc_ids"""],
        )
        self.assertEqual(retrieved_doc_embeds.shape				,				(2, n_docs, self.retrieval_vector_size)		)
        self.assertIsInstance(UpperCAmelCase__				,				torch.Tensor		)
        self.assertIsInstance(UpperCAmelCase__				,				torch.Tensor		)
        self.assertIsInstance(UpperCAmelCase__				,				torch.Tensor		)




  @require_torch
  @require_tokenizers
  @require_sentencepiece
  def  _lowercase      (			self    : Union[str, Any]		)					->Optional[Any]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Dict       =   self.get_dpr_ctx_encoder_tokenizer()
        SCREAMING_SNAKE_CASE :      Optional[int]       =   1
        SCREAMING_SNAKE_CASE :      List[Any]       =   self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase__		)
        retriever.set_ctx_encoder_tokenizer(UpperCAmelCase__		)

        SCREAMING_SNAKE_CASE :      List[str]       =   [[5, 7], [1_0, 1_1]]
        SCREAMING_SNAKE_CASE :      Optional[int]       =   np.array(
            [np.ones(self.retrieval_vector_size		), -np.ones(self.retrieval_vector_size		)]				,				dtype=np.floataa		)
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   retriever(UpperCAmelCase__				,				UpperCAmelCase__				,				prefix=retriever.config.generator.prefix				,				n_docs=UpperCAmelCase__		)

        self.assertEqual(
            len(UpperCAmelCase__		)				,				6		)  # check whether the retriever output consist of 6 attributes including tokenized docs
        self.assertEqual(
            all(k in out for k in ("""tokenized_doc_ids""", """tokenized_doc_attention_mask""")		)				,				UpperCAmelCase__		)  # check for doc token related keys in dictionary.




