




'''simple docstring'''

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


				def     A_					(						self       :   Any   ):
									snake_case_		     =							tempfile.mkdtemp()
									snake_case_		     =							5

									# Realm tok
									snake_case_		     =							[
									    '''[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''',
									]
									snake_case_		     =							os.path.join(self.tmpdirname			,							'''realm_tokenizer'''   )
									os.makedirs(lowercase_			,							exist_ok=lowercase_   )
									snake_case_		     =							os.path.join(lowercase_			,							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]   )   )

									snake_case_		     =							os.path.join(self.tmpdirname			,							'''realm_block_records'''   )
									os.makedirs(lowercase_			,							exist_ok=lowercase_   )


				def     A_					(						self       :   Any   ):
									return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname			,							'''realm_tokenizer'''   )   )


				def     A_					(						self       :   Optional[Any]   ):
									shutil.rmtree(self.tmpdirname   )


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							RealmConfig(num_block_records=self.num_block_records   )
									return config


				def     A_					(						self       :   Any   ):
									snake_case_		     =							Dataset.from_dict(
									    {
									        '''id''': ['''0''', '''1'''],
									        '''question''': ['''foo''', '''bar'''],
									        '''answers''': [['''Foo''', '''Bar'''], ['''Bar''']],
									    }   )
									return dataset


				def     A_					(						self       :   Dict   ):
									snake_case_		     =							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=lowercase_			,							)
									return block_records


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							RealmRetriever(
									    block_records=self.get_dummy_block_records()			,							tokenizer=self.get_tokenizer()			,							)
									return retriever


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							self.get_config()
									snake_case_		     =							self.get_dummy_retriever()
									snake_case_		     =							retriever.tokenizer

									snake_case_		     =							np.array([0, 3]			,							dtype='''long'''   )
									snake_case_		     =							tokenizer(['''Test question''']   ).input_ids
									snake_case_		     =							tokenizer(
									    ['''the fourth''']			,							add_special_tokens=lowercase_			,							return_token_type_ids=lowercase_			,							return_attention_mask=lowercase_			,							).input_ids
									snake_case_		     =							config.reader_seq_len

									snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							retriever(
									    lowercase_			,							lowercase_			,							answer_ids=lowercase_			,							max_length=lowercase_			,							return_tensors='''np'''   )

									self.assertEqual(len(lowercase_   )			,							2   )
									self.assertEqual(len(lowercase_   )			,							2   )
									self.assertEqual(len(lowercase_   )			,							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     A_					(						self       :   Tuple   ):
									snake_case_		     =							self.get_config()
									snake_case_		     =							self.get_dummy_retriever()
									snake_case_		     =							retriever.tokenizer

									snake_case_		     =							np.array([0, 3, 5]			,							dtype='''long'''   )
									snake_case_		     =							tokenizer(['''Test question''']   ).input_ids
									snake_case_		     =							tokenizer(
									    ['''the fourth''', '''longer longer''']			,							add_special_tokens=lowercase_			,							return_token_type_ids=lowercase_			,							return_attention_mask=lowercase_			,							).input_ids
									snake_case_		     =							config.reader_seq_len

									snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							retriever(
									    lowercase_			,							lowercase_			,							answer_ids=lowercase_			,							max_length=lowercase_			,							return_tensors='''np'''   )

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


				def     A_					(						self       :   Optional[Any]   ):
									snake_case_		     =							self.get_dummy_retriever()
									retriever.save_pretrained(os.path.join(self.tmpdirname			,							'''realm_block_records'''   )   )

									# Test local path
									snake_case_		     =							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:
														snake_case_		     =							os.path.join(
														    os.path.join(self.tmpdirname			,							'''realm_block_records'''   )			,							_REALM_BLOCK_RECORDS_FILENAME   )
														snake_case_		     =							RealmRetriever.from_pretrained('''google/realm-cc-news-pretrained-openqa'''   )

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







'''simple docstring'''

def 						__magic_name__       (      __UpperCAmelCase, __UpperCAmelCase      )						->   int:

					'''simple docstring'''

					return int((input_a, input_a).count(0      ) == 0      )


def 						__magic_name__       (      )						->   None:

					'''simple docstring'''

					assert and_gate(0, 0      ) == 0
					assert and_gate(0, 1      ) == 0
					assert and_gate(1, 0      ) == 0
					assert and_gate(1, 1      ) == 1


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

