


'''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 						_snake_case   (       a__		):




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   Tuple       				=       tempfile.mkdtemp()
								UpperCAmelCase__					:   str       				=       5

								# Realm tok
								UpperCAmelCase__					:   List[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""",
								]
								UpperCAmelCase__					:   Optional[int]       				=       os.path.join(self.tmpdirname							,							"""realm_tokenizer""")
								os.makedirs(_lowerCamelCase							,							exist_ok=_lowerCamelCase)
								UpperCAmelCase__					:   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]))

								UpperCAmelCase__					:   int       				=       os.path.join(self.tmpdirname							,							"""realm_block_records""")
								os.makedirs(_lowerCamelCase							,							exist_ok=_lowerCamelCase)




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




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




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[Any]       				=       RealmConfig(num_block_records=self.num_block_records)
								return config




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




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   Optional[int]       				=       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 			snake_case__  ( self):
								UpperCAmelCase__					:   Tuple       				=       RealmRetriever(
								    block_records=self.get_dummy_block_records()							,							tokenizer=self.get_tokenizer()							,							)
								return retriever




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   int       				=       self.get_config()
								UpperCAmelCase__					:   Optional[Any]       				=       self.get_dummy_retriever()
								UpperCAmelCase__					:   Optional[int]       				=       retriever.tokenizer

								UpperCAmelCase__					:   Union[str, Any]       				=       np.array([0, 3]							,							dtype="""long""")
								UpperCAmelCase__					:   List[Any]       				=       tokenizer(["""Test question"""]).input_ids
								UpperCAmelCase__					:   Any       				=       tokenizer(
								    ["""the fourth"""]							,							add_special_tokens=_lowerCamelCase							,							return_token_type_ids=_lowerCamelCase							,							return_attention_mask=_lowerCamelCase							,							).input_ids
								UpperCAmelCase__					:   Union[str, Any]       				=       config.reader_seq_len

								UpperCAmelCase__				,    UpperCAmelCase__				,    UpperCAmelCase__				,    UpperCAmelCase__					:   str       				=       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 			snake_case__  ( self):
								UpperCAmelCase__					:   Union[str, Any]       				=       self.get_config()
								UpperCAmelCase__					:   Tuple       				=       self.get_dummy_retriever()
								UpperCAmelCase__					:   Any       				=       retriever.tokenizer

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

								UpperCAmelCase__				,    UpperCAmelCase__				,    UpperCAmelCase__				,    UpperCAmelCase__					:   int       				=       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 			snake_case__  ( self):
								UpperCAmelCase__					:   str       				=       self.get_dummy_retriever()
								retriever.save_pretrained(os.path.join(self.tmpdirname							,							"""realm_block_records"""))

								# Test local path
								UpperCAmelCase__					:   int       				=       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:
											UpperCAmelCase__					:   Union[str, Any]       				=       os.path.join(
											    os.path.join(self.tmpdirname							,							"""realm_block_records""")							,							_REALM_BLOCK_RECORDS_FILENAME)
											UpperCAmelCase__					:   Dict       				=       RealmRetriever.from_pretrained("""google/realm-cc-news-pretrained-openqa""")

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



'''simple docstring'''



def       _UpperCamelCase (						UpperCamelCase__   ):
			UpperCAmelCase__					:   List[str]       				=       len(UpperCamelCase__   )
			UpperCAmelCase__					:   List[Any]       				=       sum(UpperCamelCase__   )

			UpperCAmelCase__					:   List[str]       				=       [[False for x in range(s + 1   )] for y in range(n + 1   )]

			for i in range(1	, n + 1   ):
						UpperCAmelCase__					:   int       				=       True

			for i in range(1	, s + 1   ):
						UpperCAmelCase__					:   Dict       				=       False

			for i in range(1	, n + 1   ):
						for j in range(1	, s + 1   ):
									UpperCAmelCase__					:   int       				=       dp[i][j - 1]

									if arr[i - 1] <= j:
												UpperCAmelCase__					:   str       				=       dp[i][j] or dp[i - 1][j - arr[i - 1]]

			for j in range(int(s / 2   )	, -1	, -1   ):
						if dp[n][j] is True:
									UpperCAmelCase__					:   int       				=       s - 2 * j
									break

			return diff