'''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 _SCREAMING_SNAKE_CASE(							lowercase_					):




						def      __lowerCamelCase       (    self :       int      )     ->				str:
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = tempfile.mkdtemp()
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = 5

													# Realm tok
													SCREAMING_SNAKE_CASE__     :List[str]						    = [
													    '[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',
													]
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = os.path.join(self.tmpdirname							,							'realm_tokenizer'      )
													os.makedirs(UpperCamelCase_							,							exist_ok=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :Dict						    = os.path.join(UpperCamelCase_							,							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]      )      )

													SCREAMING_SNAKE_CASE__     :Tuple						    = os.path.join(self.tmpdirname							,							'realm_block_records'      )
													os.makedirs(UpperCamelCase_							,							exist_ok=UpperCamelCase_      )




						def      __lowerCamelCase       (    self :       List[Any]      )     ->				Tuple:
													return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname							,							'realm_tokenizer'      )      )




						def      __lowerCamelCase       (    self :       Union[str, Any]      )     ->				List[Any]:
													shutil.rmtree(self.tmpdirname      )




						def      __lowerCamelCase       (    self :       str      )     ->				Tuple:
													SCREAMING_SNAKE_CASE__     :str						    = RealmConfig(num_block_records=self.num_block_records      )
													return config




						def      __lowerCamelCase       (    self :       Dict      )     ->				Any:
													SCREAMING_SNAKE_CASE__     :int						    = Dataset.from_dict(
													    {
													        'id': ['0', '1'],
													        'question': ['foo', 'bar'],
													        'answers': [['Foo', 'Bar'], ['Bar']],
													    }      )
													return dataset




						def      __lowerCamelCase       (    self :       str      )     ->				Tuple:
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = 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=UpperCamelCase_							,							)
													return block_records




						def      __lowerCamelCase       (    self :       List[Any]      )     ->				Any:
													SCREAMING_SNAKE_CASE__     :str						    = RealmRetriever(
													    block_records=self.get_dummy_block_records()							,							tokenizer=self.get_tokenizer()							,							)
													return retriever




						def      __lowerCamelCase       (    self :       Dict      )     ->				List[str]:
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = self.get_config()
													SCREAMING_SNAKE_CASE__     :Tuple						    = self.get_dummy_retriever()
													SCREAMING_SNAKE_CASE__     :Any						    = retriever.tokenizer

													SCREAMING_SNAKE_CASE__     :Dict						    = np.array([0, 3]							,							dtype='long'      )
													SCREAMING_SNAKE_CASE__     :List[str]						    = tokenizer(['Test question']      ).input_ids
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = tokenizer(
													    ['the fourth']							,							add_special_tokens=UpperCamelCase_							,							return_token_type_ids=UpperCamelCase_							,							return_attention_mask=UpperCamelCase_							,							).input_ids
													SCREAMING_SNAKE_CASE__     :Tuple						    = config.reader_seq_len

													SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__     :Any						    = retriever(
													    UpperCamelCase_							,							UpperCamelCase_							,							answer_ids=UpperCamelCase_							,							max_length=UpperCamelCase_							,							return_tensors='np'      )

													self.assertEqual(len(UpperCamelCase_      )							,							2      )
													self.assertEqual(len(UpperCamelCase_      )							,							2      )
													self.assertEqual(len(UpperCamelCase_      )							,							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 :       str      )     ->				int:
													SCREAMING_SNAKE_CASE__     :List[Any]						    = self.get_config()
													SCREAMING_SNAKE_CASE__     :int						    = self.get_dummy_retriever()
													SCREAMING_SNAKE_CASE__     :Any						    = retriever.tokenizer

													SCREAMING_SNAKE_CASE__     :int						    = np.array([0, 3, 5]							,							dtype='long'      )
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = tokenizer(['Test question']      ).input_ids
													SCREAMING_SNAKE_CASE__     :Any						    = tokenizer(
													    ['the fourth', 'longer longer']							,							add_special_tokens=UpperCamelCase_							,							return_token_type_ids=UpperCamelCase_							,							return_attention_mask=UpperCamelCase_							,							).input_ids
													SCREAMING_SNAKE_CASE__     :int						    = config.reader_seq_len

													SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__     :List[str]						    = retriever(
													    UpperCamelCase_							,							UpperCamelCase_							,							answer_ids=UpperCamelCase_							,							max_length=UpperCamelCase_							,							return_tensors='np'      )

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




						def      __lowerCamelCase       (    self :       str      )     ->				Optional[int]:
													SCREAMING_SNAKE_CASE__     :Tuple						    = self.get_dummy_retriever()
													retriever.save_pretrained(os.path.join(self.tmpdirname							,							'realm_block_records'      )      )

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

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














def       _SCREAMING_SNAKE_CASE    (			__lowercase :      int     )    ->   list[int]:





    """simple docstring"""

    if length <= 0 or not isinstance(__lowercase      ,					__lowercase     ):
        raise ValueError("""Length must be a positive integer."""     )
    return [n * (2 * n - 1) for n in range(__lowercase     )]


if __name__ == "__main__":
  print(hexagonal_numbers(length=5))
  print(hexagonal_numbers(length=10))




