





import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import (
					    FocalNetBackbone,
					    FocalNetForImageClassification,
					    FocalNetForMaskedImageModeling,
					    FocalNetModel,
					)
					from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor

class 							__SCREAMING_SNAKE_CASE       :






							def __init__(    self	,			__lowerCAmelCase	,			__lowerCAmelCase=13	,			__lowerCAmelCase=32	,			__lowerCAmelCase=2	,			__lowerCAmelCase=3	,			__lowerCAmelCase=16	,			__lowerCAmelCase=[32, 64, 128]	,			__lowerCAmelCase=[1, 2, 1]	,			__lowerCAmelCase=[2, 2, 4]	,			__lowerCAmelCase=2	,			__lowerCAmelCase=2.0	,			__lowerCAmelCase=True	,			__lowerCAmelCase=0.0	,			__lowerCAmelCase=0.0	,			__lowerCAmelCase=0.1	,			__lowerCAmelCase="gelu"	,			__lowerCAmelCase=False	,			__lowerCAmelCase=True	,			__lowerCAmelCase=0.02	,			__lowerCAmelCase=1E-5	,			__lowerCAmelCase=True	,			__lowerCAmelCase=None	,			__lowerCAmelCase=True	,			__lowerCAmelCase=10	,			__lowerCAmelCase=8	,			__lowerCAmelCase=["stage1", "stage2"]	,			__lowerCAmelCase=[1, 2]	,			):
														UpperCamelCase__					  =      parent
														UpperCamelCase__					  =      batch_size
														UpperCamelCase__					  =      image_size
														UpperCamelCase__					  =      patch_size
														UpperCamelCase__					  =      num_channels
														UpperCamelCase__					  =      embed_dim
														UpperCamelCase__					  =      hidden_sizes
														UpperCamelCase__					  =      depths
														UpperCamelCase__					  =      num_heads
														UpperCamelCase__					  =      window_size
														UpperCamelCase__					  =      mlp_ratio
														UpperCamelCase__					  =      qkv_bias
														UpperCamelCase__					  =      hidden_dropout_prob
														UpperCamelCase__					  =      attention_probs_dropout_prob
														UpperCamelCase__					  =      drop_path_rate
														UpperCamelCase__					  =      hidden_act
														UpperCamelCase__					  =      use_absolute_embeddings
														UpperCamelCase__					  =      patch_norm
														UpperCamelCase__					  =      layer_norm_eps
														UpperCamelCase__					  =      initializer_range
														UpperCamelCase__					  =      is_training
														UpperCamelCase__					  =      scope
														UpperCamelCase__					  =      use_labels
														UpperCamelCase__					  =      type_sequence_label_size
														UpperCamelCase__					  =      encoder_stride
														UpperCamelCase__					  =      out_features
														UpperCamelCase__					  =      out_indices






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

														UpperCamelCase__					  =      self.get_config()

														return config, pixel_values, labels






							def 					_lowerCamelCase		(    self	):
														return FocalNetConfig(
														    image_size=self.image_size	,			patch_size=self.patch_size	,			num_channels=self.num_channels	,			embed_dim=self.embed_dim	,			hidden_sizes=self.hidden_sizes	,			depths=self.depths	,			num_heads=self.num_heads	,			window_size=self.window_size	,			mlp_ratio=self.mlp_ratio	,			qkv_bias=self.qkv_bias	,			hidden_dropout_prob=self.hidden_dropout_prob	,			attention_probs_dropout_prob=self.attention_probs_dropout_prob	,			drop_path_rate=self.drop_path_rate	,			hidden_act=self.hidden_act	,			use_absolute_embeddings=self.use_absolute_embeddings	,			path_norm=self.patch_norm	,			layer_norm_eps=self.layer_norm_eps	,			initializer_range=self.initializer_range	,			encoder_stride=self.encoder_stride	,			out_features=self.out_features	,			out_indices=self.out_indices	,			)






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      FocalNetModel(config=__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()
														UpperCamelCase__					  =      model(__lowerCAmelCase	)

														UpperCamelCase__					  =      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
														UpperCamelCase__					  =      int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

														self.parent.assertEqual(result.last_hidden_state.shape	,			(self.batch_size, expected_seq_len, expected_dim)	)






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      FocalNetBackbone(config=__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()
														UpperCamelCase__					  =      model(__lowerCAmelCase	)

														# verify feature maps
														self.parent.assertEqual(len(result.feature_maps	)	,			len(config.out_features	)	)
														self.parent.assertListEqual(list(result.feature_maps[0].shape	)	,			[self.batch_size, self.image_size, 8, 8]	)

														# verify channels
														self.parent.assertEqual(len(model.channels	)	,			len(config.out_features	)	)
														self.parent.assertListEqual(model.channels	,			config.hidden_sizes[:-1]	)

														# verify backbone works with out_features=None
														UpperCamelCase__					  =      None
														UpperCamelCase__					  =      FocalNetBackbone(config=__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()
														UpperCamelCase__					  =      model(__lowerCAmelCase	)

														# verify feature maps
														self.parent.assertEqual(len(result.feature_maps	)	,			1	)
														self.parent.assertListEqual(list(result.feature_maps[0].shape	)	,			[self.batch_size, self.image_size * 2, 4, 4]	)

														# verify channels
														self.parent.assertEqual(len(model.channels	)	,			1	)
														self.parent.assertListEqual(model.channels	,			[config.hidden_sizes[-1]]	)






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      FocalNetForMaskedImageModeling(config=__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()
														UpperCamelCase__					  =      model(__lowerCAmelCase	)
														self.parent.assertEqual(
														    result.reconstruction.shape	,			(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

														# test greyscale images
														UpperCamelCase__					  =      1
														UpperCamelCase__					  =      FocalNetForMaskedImageModeling(__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()

														UpperCamelCase__					  =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
														UpperCamelCase__					  =      model(__lowerCAmelCase	)
														self.parent.assertEqual(result.reconstruction.shape	,			(self.batch_size, 1, self.image_size, self.image_size)	)






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      self.type_sequence_label_size
														UpperCamelCase__					  =      FocalNetForImageClassification(__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()
														UpperCamelCase__					  =      model(__lowerCAmelCase	,			labels=__lowerCAmelCase	)
														self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.type_sequence_label_size)	)

														# test greyscale images
														UpperCamelCase__					  =      1
														UpperCamelCase__					  =      FocalNetForImageClassification(__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()

														UpperCamelCase__					  =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
														UpperCamelCase__					  =      model(__lowerCAmelCase	)
														self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.type_sequence_label_size)	)







							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      self.prepare_config_and_inputs()

														UpperCamelCase__  ,  UpperCamelCase__  ,  UpperCamelCase__					  =      config_and_inputs
														UpperCamelCase__					  =      {"""pixel_values""": pixel_values}
														return config, inputs_dict






@require_torch
class 							__SCREAMING_SNAKE_CASE       (  _a ,		_a ,		unittest.TestCase							):
							snake_case  :   Optional[Any]      =							(
							    (
							        FocalNetModel,
							        FocalNetForImageClassification,
							        FocalNetForMaskedImageModeling,
							        FocalNetBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							snake_case  :   Tuple      =							(
							    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
							    if is_torch_available()
							    else {}
							)
							snake_case  :   int      =							False

							snake_case  :   List[Any]      =							False
							snake_case  :   Optional[int]      =							False
							snake_case  :   List[Any]      =							False
							snake_case  :   Any      =							False






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      FocalNetModelTester(self	)
														UpperCamelCase__					  =      ConfigTester(self	,			config_class=__lowerCAmelCase	,			embed_dim=37	,			has_text_modality=__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														self.create_and_test_config_common_properties()
														self.config_tester.create_and_test_config_to_json_string()
														self.config_tester.create_and_test_config_to_json_file()
														self.config_tester.create_and_test_config_from_and_save_pretrained()
														self.config_tester.create_and_test_config_with_num_labels()
														self.config_tester.check_config_can_be_init_without_params()
														self.config_tester.check_config_arguments_init()






							def 					_lowerCamelCase		(    self	):
														return






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_backbone(*__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase	)






							@unittest.skip(reason="""FocalNet does not use inputs_embeds"""	)
							def 					_lowerCamelCase		(    self	):
														pass






							@unittest.skip(reason="""FocalNet does not use feedforward chunking"""	)
							def 					_lowerCamelCase		(    self	):
														pass






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__  ,  UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes[:-1]:
																					UpperCamelCase__					  =      model_class(__lowerCAmelCase	)
																					self.assertIsInstance(model.get_input_embeddings()	,			(nn.Module)	)
																					UpperCamelCase__					  =      model.get_output_embeddings()
																					self.assertTrue(x is None or isinstance(__lowerCAmelCase	,			nn.Linear	)	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__  ,  UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs_for_common()

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

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






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	):
														UpperCamelCase__					  =      model_class(__lowerCAmelCase	)
														model.to(__lowerCAmelCase	)
														model.eval()

														with torch.no_grad():
																					UpperCamelCase__					  =      model(**self._prepare_for_class(__lowerCAmelCase	,			__lowerCAmelCase	)	)

														UpperCamelCase__					  =      outputs.hidden_states

														UpperCamelCase__					  =      getattr(
														    self.model_tester	,			"""expected_num_hidden_layers"""	,			len(self.model_tester.depths	) + 1	)
														self.assertEqual(len(__lowerCAmelCase	)	,			__lowerCAmelCase	)

														# FocalNet has a different seq_length
														UpperCamelCase__					  =      (
														    config.patch_size
														    if isinstance(config.patch_size	,			collections.abc.Iterable	)
														    else (config.patch_size, config.patch_size)
														)

														UpperCamelCase__					  =      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

														self.assertListEqual(
														    list(hidden_states[0].shape[-2:]	)	,			[num_patches, self.model_tester.embed_dim]	,			)

														UpperCamelCase__					  =      outputs.reshaped_hidden_states
														self.assertEqual(len(__lowerCAmelCase	)	,			__lowerCAmelCase	)

														UpperCamelCase__  ,  UpperCamelCase__  ,  UpperCamelCase__  ,  UpperCamelCase__					  =      reshaped_hidden_states[0].shape
														UpperCamelCase__					  =      (
														    reshaped_hidden_states[0].view(__lowerCAmelCase	,			__lowerCAmelCase	,			height * width	).permute(0	,			2	,			1	)
														)
														self.assertListEqual(
														    list(reshaped_hidden_states.shape[-2:]	)	,			[num_patches, self.model_tester.embed_dim]	,			)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__  ,  UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs_for_common()

														UpperCamelCase__					  =      (
														    self.model_tester.image_size
														    if isinstance(self.model_tester.image_size	,			collections.abc.Iterable	)
														    else (self.model_tester.image_size, self.model_tester.image_size)
														)

														for model_class in self.all_model_classes[:-1]:
																					UpperCamelCase__					  =      True
																					self.check_hidden_states_output(__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	)

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

																					self.check_hidden_states_output(__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	)






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__  ,  UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs_for_common()
														UpperCamelCase__					  =      3

														UpperCamelCase__					  =      (
														    self.model_tester.image_size
														    if isinstance(self.model_tester.image_size	,			collections.abc.Iterable	)
														    else (self.model_tester.image_size, self.model_tester.image_size)
														)
														UpperCamelCase__					  =      (
														    config.patch_size
														    if isinstance(config.patch_size	,			collections.abc.Iterable	)
														    else (config.patch_size, config.patch_size)
														)

														UpperCamelCase__					  =      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
														UpperCamelCase__					  =      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

														for model_class in self.all_model_classes[:-1]:
																					UpperCamelCase__					  =      True
																					self.check_hidden_states_output(__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	,			(padded_height, padded_width)	)

																					# check that output_hidden_states also work using config
																					del inputs_dict["output_hidden_states"]
																					UpperCamelCase__					  =      True
																					self.check_hidden_states_output(__lowerCAmelCase	,			__lowerCAmelCase	,			__lowerCAmelCase	,			(padded_height, padded_width)	)






							@slow
							def 					_lowerCamelCase		(    self	):
														for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					UpperCamelCase__					  =      FocalNetModel.from_pretrained(__lowerCAmelCase	)
																					self.assertIsNotNone(__lowerCAmelCase	)







							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__  ,  UpperCamelCase__					  =      self.model_tester.prepare_config_and_inputs_for_common()

														UpperCamelCase__					  =      _config_zero_init(__lowerCAmelCase	)
														for model_class in self.all_model_classes:
																					UpperCamelCase__					  =      model_class(config=__lowerCAmelCase	)
																					for name, param in model.named_parameters():
																												if "embeddings" not in name and param.requires_grad:
																																			self.assertIn(
																																			    ((param.data.mean() * 1E9).round() / 1E9).item()	,			[0.0, 1.0]	,			msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""	,			)






@require_vision
@require_torch
class 							__SCREAMING_SNAKE_CASE       (  unittest.TestCase							):






							@cached_property
							def 					_lowerCamelCase		(    self	):
														# TODO update organization
														return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""	) if is_vision_available() else None







							@slow
							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""	).to(__lowerCAmelCase	)
														UpperCamelCase__					  =      self.default_image_processor

														UpperCamelCase__					  =      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
														UpperCamelCase__					  =      image_processor(images=__lowerCAmelCase	,			return_tensors="""pt"""	).to(__lowerCAmelCase	)

														# forward pass
														with torch.no_grad():
																					UpperCamelCase__					  =      model(**__lowerCAmelCase	)

														# verify the logits
														UpperCamelCase__					  =      torch.Size((1, 1000)	)
														self.assertEqual(outputs.logits.shape	,			__lowerCAmelCase	)
														UpperCamelCase__					  =      torch.tensor([0.2166, -0.4368, 0.2191]	).to(__lowerCAmelCase	)
														self.assertTrue(torch.allclose(outputs.logits[0, :3]	,			__lowerCAmelCase	,			atol=1E-4	)	)
														self.assertTrue(outputs.logits.argmax(dim=-1	).item()	,			281	)






@require_torch
class 							__SCREAMING_SNAKE_CASE       (  _a ,		unittest.TestCase							):
							snake_case  :   List[Any]      =							(FocalNetBackbone,) if is_torch_available() else ()
							snake_case  :   Any      =							FocalNetConfig

							snake_case  :   Optional[int]      =							False






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      FocalNetModelTester(self	)











import json
import os
import shutil
import tempfile
from unittest import TestCase

from transformers import BartTokenizer, BartTokenizerFast, DPRQuestionEncoderTokenizer, DPRQuestionEncoderTokenizerFast
from transformers.models.bart.configuration_bart import BartConfig
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.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_tokenizers, require_torch, slow
from transformers.utils import is_datasets_available, is_faiss_available, is_torch_available


if is_torch_available() and is_datasets_available() and is_faiss_available():
					from transformers.models.rag.configuration_rag import RagConfig
					from transformers.models.rag.tokenization_rag import RagTokenizer

@require_faiss
@require_torch
class 							__SCREAMING_SNAKE_CASE       (  _a							):






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      tempfile.mkdtemp()
														UpperCamelCase__					  =      8

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

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






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






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






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






							@require_tokenizers
							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      os.path.join(self.tmpdirname	,			"""rag_tokenizer"""	)
														UpperCamelCase__					  =      RagConfig(question_encoder=DPRConfig().to_dict()	,			generator=BartConfig().to_dict()	)
														UpperCamelCase__					  =      RagTokenizer(question_encoder=self.get_dpr_tokenizer()	,			generator=self.get_bart_tokenizer()	)
														rag_config.save_pretrained(__lowerCAmelCase	)
														rag_tokenizer.save_pretrained(__lowerCAmelCase	)
														UpperCamelCase__					  =      RagTokenizer.from_pretrained(__lowerCAmelCase	,			config=__lowerCAmelCase	)
														self.assertIsInstance(new_rag_tokenizer.question_encoder	,			__lowerCAmelCase	)
														self.assertEqual(new_rag_tokenizer.question_encoder.get_vocab()	,			rag_tokenizer.question_encoder.get_vocab()	)
														self.assertIsInstance(new_rag_tokenizer.generator	,			__lowerCAmelCase	)
														self.assertEqual(new_rag_tokenizer.generator.get_vocab()	,			rag_tokenizer.generator.get_vocab()	)






							@slow
							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      RagTokenizer.from_pretrained("""facebook/rag-token-nq"""	)
														UpperCamelCase__					  =      [
														    """who got the first nobel prize in physics""",
														    """when is the next deadpool movie being released""",
														    """which mode is used for short wave broadcast service""",
														    """who is the owner of reading football club""",
														    """when is the next scandal episode coming out""",
														    """when is the last time the philadelphia won the superbowl""",
														    """what is the most current adobe flash player version""",
														    """how many episodes are there in dragon ball z""",
														    """what is the first step in the evolution of the eye""",
														    """where is gall bladder situated in human body""",
														    """what is the main mineral in lithium batteries""",
														    """who is the president of usa right now""",
														    """where do the greasers live in the outsiders""",
														    """panda is a national animal of which country""",
														    """what is the name of manchester united stadium""",
														]
														UpperCamelCase__					  =      tokenizer(__lowerCAmelCase	)
														self.assertIsNotNone(__lowerCAmelCase	)







							@slow
							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      RagTokenizer.from_pretrained("""facebook/rag-sequence-nq"""	)
														UpperCamelCase__					  =      [
														    """who got the first nobel prize in physics""",
														    """when is the next deadpool movie being released""",
														    """which mode is used for short wave broadcast service""",
														    """who is the owner of reading football club""",
														    """when is the next scandal episode coming out""",
														    """when is the last time the philadelphia won the superbowl""",
														    """what is the most current adobe flash player version""",
														    """how many episodes are there in dragon ball z""",
														    """what is the first step in the evolution of the eye""",
														    """where is gall bladder situated in human body""",
														    """what is the main mineral in lithium batteries""",
														    """who is the president of usa right now""",
														    """where do the greasers live in the outsiders""",
														    """panda is a national animal of which country""",
														    """what is the name of manchester united stadium""",
														]
														UpperCamelCase__					  =      tokenizer(__lowerCAmelCase	)
														self.assertIsNotNone(__lowerCAmelCase	)




