





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

import numpy as np
from datasets import Dataset

from transformers.models.realm.configuration_realm import RealmConfig
from transformers.models.realm.retrieval_realm import _REALM_BLOCK_RECORDS_FILENAME, RealmRetriever
from transformers.models.realm.tokenization_realm import VOCAB_FILES_NAMES, RealmTokenizer

class 		lowerCAmelCase     ( UpperCAmelCase__			):

					'''simple docstring'''

					def       lowerCAmelCase				(  self				:	Dict							)			->  Any:


												"""simple docstring"""

												__lowercase      :							List[Any]				=     tempfile.mkdtemp()
												__lowercase      :							Optional[int]				=     5

												# Realm tok
												__lowercase      :							Optional[Any]				=     [
												    """[UNK]""",
												    """[CLS]""",
												    """[SEP]""",
												    """[PAD]""",
												    """[MASK]""",
												    """test""",
												    """question""",
												    """this""",
												    """is""",
												    """the""",
												    """first""",
												    """second""",
												    """third""",
												    """fourth""",
												    """fifth""",
												    """record""",
												    """want""",
												    """##want""",
												    """##ed""",
												    """wa""",
												    """un""",
												    """runn""",
												    """##ing""",
												    """,""",
												    """low""",
												    """lowest""",
												]
												__lowercase      :							Union[str, Any]				=     os.path.join(self.tmpdirname		,     """realm_tokenizer"""							)
												os.makedirs(__lowerCAmelCase		,     exist_ok=__lowerCAmelCase							)
												__lowercase      :							List[Any]				=     os.path.join(__lowerCAmelCase		,     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]							)							)

												__lowercase      :							Union[str, Any]				=     os.path.join(self.tmpdirname		,     """realm_block_records"""							)
												os.makedirs(__lowerCAmelCase		,     exist_ok=__lowerCAmelCase							)



					def       lowerCAmelCase				(  self				:	List[str]							)			->  RealmTokenizer:


												"""simple docstring"""

												return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname		,     """realm_tokenizer"""							)							)



					def       lowerCAmelCase				(  self				:	Dict							)			->  int:


												"""simple docstring"""

												shutil.rmtree(self.tmpdirname							)



					def       lowerCAmelCase				(  self				:	List[str]							)			->  List[str]:


												"""simple docstring"""

												__lowercase      :							Optional[int]				=     RealmConfig(num_block_records=self.num_block_records							)
												return config



					def       lowerCAmelCase				(  self				:	str							)			->  Optional[Any]:


												"""simple docstring"""

												__lowercase      :							Union[str, Any]				=     Dataset.from_dict(
												    {
												        """id""": ["""0""", """1"""],
												        """question""": ["""foo""", """bar"""],
												        """answers""": [["""Foo""", """Bar"""], ["""Bar"""]],
												    }							)
												return dataset



					def       lowerCAmelCase				(  self				:	Tuple							)			->  Union[str, Any]:


												"""simple docstring"""

												__lowercase      :							str				=     np.array(
												    [
												        B"""This is the first record""",
												        B"""This is the second record""",
												        B"""This is the third record""",
												        B"""This is the fourth record""",
												        B"""This is the fifth record""",
												        B"""This is a longer longer longer record""",
												    ]		,     dtype=__lowerCAmelCase		,     )
												return block_records



					def       lowerCAmelCase				(  self				:	Any							)			->  Dict:


												"""simple docstring"""

												__lowercase      :							List[str]				=     RealmRetriever(
												    block_records=self.get_dummy_block_records()		,     tokenizer=self.get_tokenizer()		,     )
												return retriever



					def       lowerCAmelCase				(  self				:	List[Any]							)			->  Optional[Any]:


												"""simple docstring"""

												__lowercase      :							Optional[int]				=     self.get_config()
												__lowercase      :							str				=     self.get_dummy_retriever()
												__lowercase      :							Optional[Any]				=     retriever.tokenizer

												__lowercase      :							Dict				=     np.array([0, 3]		,     dtype="""long"""							)
												__lowercase      :							Tuple				=     tokenizer(["""Test question"""]							).input_ids
												__lowercase      :							int				=     tokenizer(
												    ["""the fourth"""]		,     add_special_tokens=__lowerCAmelCase		,     return_token_type_ids=__lowerCAmelCase		,     return_attention_mask=__lowerCAmelCase		,     ).input_ids
												__lowercase      :							Union[str, Any]				=     config.reader_seq_len

												__lowercase			,			__lowercase			,			__lowercase			,			__lowercase      :							int				=     retriever(
												    __lowerCAmelCase		,     __lowerCAmelCase		,     answer_ids=__lowerCAmelCase		,     max_length=__lowerCAmelCase		,     return_tensors="""np"""							)

												self.assertEqual(len(__lowerCAmelCase							)		,     2							)
												self.assertEqual(len(__lowerCAmelCase							)		,     2							)
												self.assertEqual(len(__lowerCAmelCase							)		,     2							)
												self.assertEqual(concat_inputs.input_ids.shape		,     (2, 10)							)
												self.assertEqual(concat_inputs.attention_mask.shape		,     (2, 10)							)
												self.assertEqual(concat_inputs.token_type_ids.shape		,     (2, 10)							)
												self.assertEqual(concat_inputs.special_tokens_mask.shape		,     (2, 10)							)
												self.assertEqual(
												    tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[0]							)		,     ["""[CLS]""", """test""", """question""", """[SEP]""", """this""", """is""", """the""", """first""", """record""", """[SEP]"""]		,     )
												self.assertEqual(
												    tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[1]							)		,     ["""[CLS]""", """test""", """question""", """[SEP]""", """this""", """is""", """the""", """fourth""", """record""", """[SEP]"""]		,     )



					def       lowerCAmelCase				(  self				:	int							)			->  int:


												"""simple docstring"""

												__lowercase      :							Dict				=     self.get_config()
												__lowercase      :							Union[str, Any]				=     self.get_dummy_retriever()
												__lowercase      :							Optional[Any]				=     retriever.tokenizer

												__lowercase      :							Tuple				=     np.array([0, 3, 5]		,     dtype="""long"""							)
												__lowercase      :							int				=     tokenizer(["""Test question"""]							).input_ids
												__lowercase      :							str				=     tokenizer(
												    ["""the fourth""", """longer longer"""]		,     add_special_tokens=__lowerCAmelCase		,     return_token_type_ids=__lowerCAmelCase		,     return_attention_mask=__lowerCAmelCase		,     ).input_ids
												__lowercase      :							Optional[int]				=     config.reader_seq_len

												__lowercase			,			__lowercase			,			__lowercase			,			__lowercase      :							Union[str, Any]				=     retriever(
												    __lowerCAmelCase		,     __lowerCAmelCase		,     answer_ids=__lowerCAmelCase		,     max_length=__lowerCAmelCase		,     return_tensors="""np"""							)

												self.assertEqual([False, True, True]		,     __lowerCAmelCase							)
												self.assertEqual([[-1, -1, -1], [6, -1, -1], [6, 7, 8]]		,     __lowerCAmelCase							)
												self.assertEqual([[-1, -1, -1], [7, -1, -1], [7, 8, 9]]		,     __lowerCAmelCase							)



					def       lowerCAmelCase				(  self				:	Union[str, Any]							)			->  Tuple:


												"""simple docstring"""

												__lowercase      :							Dict				=     self.get_dummy_retriever()
												retriever.save_pretrained(os.path.join(self.tmpdirname		,     """realm_block_records"""							)							)

												# Test local path
												__lowercase      :							Tuple				=     retriever.from_pretrained(os.path.join(self.tmpdirname		,     """realm_block_records"""							)							)
												self.assertEqual(retriever.block_records[0]		,     B"""This is the first record"""							)

												# Test mocked remote path
												with patch("""transformers.models.realm.retrieval_realm.hf_hub_download"""							) as mock_hf_hub_download:
																			__lowercase      :							List[str]				=     os.path.join(
																			    os.path.join(self.tmpdirname		,     """realm_block_records"""							)		,     _REALM_BLOCK_RECORDS_FILENAME							)
																			__lowercase      :							str				=     RealmRetriever.from_pretrained("""google/realm-cc-news-pretrained-openqa"""							)

												self.assertEqual(retriever.block_records[0]		,     B"""This is the first record"""							)







def       snake_case_		(     lowerCAmelCase_       :						int       ,       lowerCAmelCase_       :						int      ):
							return int((input_a, input_a).count(1      ) != 0      )
def       snake_case_		(     ):
							assert or_gate(0       ,       0      ) == 0
							assert or_gate(0       ,       1      ) == 1
							assert or_gate(1       ,       0      ) == 1
							assert or_gate(1       ,       1      ) == 1


if __name__ == "__main__":
	print(or_gate(0, 1))
	print(or_gate(1, 0))
	print(or_gate(0, 0))
	print(or_gate(1, 1))