





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     (						a    ):


				def _snake_case       (		self							):
								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(UpperCAmelCase_   , exist_ok=UpperCAmelCase_							)
								lowerCamelCase	 =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
								lowerCamelCase	 =[
								    """l""",
								    """o""",
								    """w""",
								    """e""",
								    """r""",
								    """s""",
								    """t""",
								    """i""",
								    """d""",
								    """n""",
								    """\u0120""",
								    """\u0120l""",
								    """\u0120n""",
								    """\u0120lo""",
								    """\u0120low""",
								    """er""",
								    """\u0120lowest""",
								    """\u0120newer""",
								    """\u0120wider""",
								    """<unk>""",
								]
								lowerCamelCase	 =dict(zip(UpperCAmelCase_   , range(len(UpperCAmelCase_							)							)							)							)
								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(UpperCAmelCase_   , exist_ok=UpperCAmelCase_							)
								lowerCamelCase	 =os.path.join(UpperCAmelCase_   , BART_VOCAB_FILES_NAMES["""vocab_file"""]							)
								lowerCamelCase	 =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 _snake_case       (		self							):
								return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname   , """dpr_tokenizer"""							)							)


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


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


				def _snake_case       (		self							):
								shutil.rmtree(self.tmpdirname							)


				def _snake_case       (		self							):
								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 _snake_case       (		self							):
								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	 =RagRetriever(
												    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()   , )
								return retriever


				def _snake_case       (		self   , UpperCAmelCase_							):
								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	 =RagRetriever(
												    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()   , )
								else:
												lowerCamelCase	 =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 _snake_case       (		self							):
								lowerCamelCase	 =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							)

								lowerCamelCase	 =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"""							)							)

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

								lowerCamelCase	 =RagConfig(
								    retrieval_vector_size=self.retrieval_vector_size   , question_encoder=DPRConfig().to_dict()   , generator=BartConfig().to_dict()   , index_name="""legacy"""   , index_path=self.tmpdirname   , )
								lowerCamelCase	 =RagRetriever(
								    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()							)
								return retriever


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_canonical_hf_index_retriever()
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =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 _snake_case       (		self							):
								lowerCamelCase	 =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:
																lowerCamelCase	 =self.get_dummy_dataset()
																retriever.save_pretrained(UpperCAmelCase_							)
																lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
																self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
																lowerCamelCase	 =np.array(
																    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
																lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
																self.assertTrue(out is not None							)


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =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 _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								with tempfile.TemporaryDirectory() as tmp_dirname:
												retriever.save_pretrained(UpperCAmelCase_							)
												lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
												self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
												lowerCamelCase	 =np.array(
												    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
												lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
												self.assertTrue(out is not None							)


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =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 _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								with tempfile.TemporaryDirectory() as tmp_dirname:
												retriever.save_pretrained(UpperCAmelCase_							)
												lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
												self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
												lowerCamelCase	 =np.array(
												    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
												lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
												self.assertTrue(out is not None							)


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_legacy_index_retriever()
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =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 _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_legacy_index_retriever()
								with tempfile.TemporaryDirectory() as tmp_dirname:
												retriever.save_pretrained(UpperCAmelCase_							)
												lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
												self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
												lowerCamelCase	 =np.array(
												    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
												lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
												self.assertTrue(out is not None							)


				@require_torch
				@require_tokenizers
				@require_sentencepiece
				def _snake_case       (		self							):
								import torch

								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_canonical_hf_index_retriever()
								lowerCamelCase	 =[[5, 7], [10, 11]]
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase	 =retriever(UpperCAmelCase_   , UpperCAmelCase_   , prefix=retriever.config.generator.prefix   , n_docs=UpperCAmelCase_							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =(
								    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							)

								lowerCamelCase	 =retriever(
								    UpperCAmelCase_   , UpperCAmelCase_   , prefix=retriever.config.generator.prefix   , n_docs=UpperCAmelCase_   , return_tensors="""pt"""   , )
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =(  # 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 _snake_case       (		self							):
								lowerCamelCase	 =self.get_dpr_ctx_encoder_tokenizer()
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								retriever.set_ctx_encoder_tokenizer(UpperCAmelCase_							)

								lowerCamelCase	 =[[5, 7], [10, 11]]
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase	 =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.












from tempfile import TemporaryDirectory
from unittest import TestCase
from unittest.mock import MagicMock, patch

from transformers import AutoModel, TFAutoModel
from transformers.onnx import FeaturesManager
from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch

@require_torch
@require_tf
class       __A     (						a    ):


				def _snake_case       (		self							):
								lowerCamelCase	 =SMALL_MODEL_IDENTIFIER
								lowerCamelCase	 ="""pt"""
								lowerCamelCase	 ="""tf"""


				def _snake_case       (		self   , UpperCAmelCase_							):
								lowerCamelCase	 =AutoModel.from_pretrained(self.test_model							)
								model_pt.save_pretrained(UpperCAmelCase_							)


				def _snake_case       (		self   , UpperCAmelCase_							):
								lowerCamelCase	 =TFAutoModel.from_pretrained(self.test_model   , from_pt=UpperCAmelCase_							)
								model_tf.save_pretrained(UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 ="""mock_framework"""

								# Framework provided - return whatever the user provides
								lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model   , UpperCAmelCase_							)
								self.assertEqual(UpperCAmelCase_   , UpperCAmelCase_							)

								# Local checkpoint and framework provided - return provided framework
								# PyTorch checkpoint
								with TemporaryDirectory() as local_pt_ckpt:
												self._setup_pt_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_   , UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , UpperCAmelCase_							)

								# TensorFlow checkpoint
								with TemporaryDirectory() as local_tf_ckpt:
												self._setup_tf_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_   , UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , UpperCAmelCase_							)


				def _snake_case       (		self							):
								# PyTorch checkpoint
								with TemporaryDirectory() as local_pt_ckpt:
												self._setup_pt_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , self.framework_pt							)

								# TensorFlow checkpoint
								with TemporaryDirectory() as local_tf_ckpt:
												self._setup_tf_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , self.framework_tf							)

								# Invalid local checkpoint
								with TemporaryDirectory() as local_invalid_ckpt:
												with self.assertRaises(UpperCAmelCase_							):
																lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_tf_available"""   , UpperCAmelCase_							):
												lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)
												self.assertEqual(UpperCAmelCase_   , self.framework_pt							)

								# PyTorch not in environment -> use TensorFlow
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_torch_available"""   , UpperCAmelCase_							):
												lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)
												self.assertEqual(UpperCAmelCase_   , self.framework_tf							)

								# Both in environment -> use PyTorch
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_tf_available"""   , UpperCAmelCase_							), patch(
								    """transformers.onnx.features.is_torch_available"""   , UpperCAmelCase_							):
												lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)
												self.assertEqual(UpperCAmelCase_   , self.framework_pt							)

								# Both not in environment -> raise error
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_tf_available"""   , UpperCAmelCase_							), patch(
								    """transformers.onnx.features.is_torch_available"""   , UpperCAmelCase_							):
												with self.assertRaises(UpperCAmelCase_							):
																lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)





