



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  __snake_case      (   __A):







							'''simple docstring'''






							def _a      (							self		):
											a__				      =		tempfile.mkdtemp()
											a__				      =		5

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

											a__				      =		os.path.join(self.tmpdirname  ,  """realm_block_records"""		)
											os.makedirs(a_  ,  exist_ok=a_		)


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


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


							def _a      (							self		):
											a__				      =		RealmConfig(num_block_records=self.num_block_records		)
											return config


							def _a      (							self		):
											a__				      =		Dataset.from_dict(
											    {
											        """id""": ["""0""", """1"""],
											        """question""": ["""foo""", """bar"""],
											        """answers""": [["""Foo""", """Bar"""], ["""Bar"""]],
											    }		)
											return dataset


							def _a      (							self		):
											a__				      =		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=a_  ,  )
											return block_records


							def _a      (							self		):
											a__				      =		RealmRetriever(
											    block_records=self.get_dummy_block_records()  ,  tokenizer=self.get_tokenizer()  ,  )
											return retriever


							def _a      (							self		):
											a__				      =		self.get_config()
											a__				      =		self.get_dummy_retriever()
											a__				      =		retriever.tokenizer

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

											a__				      =		retriever(
											    a_  ,  a_  ,  answer_ids=a_  ,  max_length=a_  ,  return_tensors="""np"""		)

											self.assertEqual(len(a_		)  ,  2		)
											self.assertEqual(len(a_		)  ,  2		)
											self.assertEqual(len(a_		)  ,  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		):
											a__				      =		self.get_config()
											a__				      =		self.get_dummy_retriever()
											a__				      =		retriever.tokenizer

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

											a__				      =		retriever(
											    a_  ,  a_  ,  answer_ids=a_  ,  max_length=a_  ,  return_tensors="""np"""		)

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







							def _a      (							self		):
											a__				      =		self.get_dummy_retriever()
											retriever.save_pretrained(os.path.join(self.tmpdirname  ,  """realm_block_records"""		)		)

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

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






def 			A_      (	__a     :				int ,		__a     :				int		):

				"""simple docstring"""
				return abs(__a		) if a == 0 else greatest_common_divisor(b % a ,		__a		)

def 			A_      (	__a     :				int ,		__a     :				int		):

				"""simple docstring"""
				while y:  # --> when y=0 then loop will terminate and return x as final GCD.
								a__      ,			a__				      =		y, x % y
				return abs(__a		)

def 			A_      (	):

				"""simple docstring"""
				try:
								a__				      =		input("""Enter two integers separated by comma (,): """		).split(""","""		)
								a__				      =		int(nums[0]		)
								a__				      =		int(nums[1]		)
								print(
								    F'''greatest_common_divisor({num_a}, {num_a}) = '''
								    F'''{greatest_common_divisor(__a ,		__a		)}'''		)
								print(F'''By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(__a ,		__a		)}'''		)
				except (IndexError, UnboundLocalError, ValueError):
								print("""Wrong input"""		)


if __name__ == "__main__":
	main()

