




'''simple docstring'''




import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
UpperCAmelCase_												=   logging.get_logger('transformers.models.encodec')

UpperCAmelCase_												=   {
    "quantizer.vq.layers.*._codebook.inited": "quantizer.layers.*.codebook.inited",
    "quantizer.vq.layers.*._codebook.cluster_size": "quantizer.layers.*.codebook.cluster_size",
    "quantizer.vq.layers.*._codebook.embed": "quantizer.layers.*.codebook.embed",
    "quantizer.vq.layers.*._codebook.embed_avg": "quantizer.layers.*.codebook.embed_avg",
}
UpperCAmelCase_												=   {
    "encoder.model.0.conv.conv": "encoder.layers.0.conv",
    "encoder.model.1.block.1.conv.conv": "encoder.layers.1.block.1.conv",
    "encoder.model.1.block.3.conv.conv": "encoder.layers.1.block.3.conv",
    "encoder.model.1.shortcut.conv.conv": "encoder.layers.1.shortcut.conv",
    "encoder.model.3.conv.conv": "encoder.layers.3.conv",
    "encoder.model.4.block.1.conv.conv": "encoder.layers.4.block.1.conv",
    "encoder.model.4.block.3.conv.conv": "encoder.layers.4.block.3.conv",
    "encoder.model.4.shortcut.conv.conv": "encoder.layers.4.shortcut.conv",
    "encoder.model.6.conv.conv": "encoder.layers.6.conv",
    "encoder.model.7.block.1.conv.conv": "encoder.layers.7.block.1.conv",
    "encoder.model.7.block.3.conv.conv": "encoder.layers.7.block.3.conv",
    "encoder.model.7.shortcut.conv.conv": "encoder.layers.7.shortcut.conv",
    "encoder.model.9.conv.conv": "encoder.layers.9.conv",
    "encoder.model.10.block.1.conv.conv": "encoder.layers.10.block.1.conv",
    "encoder.model.10.block.3.conv.conv": "encoder.layers.10.block.3.conv",
    "encoder.model.10.shortcut.conv.conv": "encoder.layers.10.shortcut.conv",
    "encoder.model.12.conv.conv": "encoder.layers.12.conv",
    "encoder.model.13.lstm": "encoder.layers.13.lstm",
    "encoder.model.15.conv.conv": "encoder.layers.15.conv",
}
UpperCAmelCase_												=   {
    "encoder.model.0.conv.norm": "encoder.layers.0.norm",
    "encoder.model.1.block.1.conv.norm": "encoder.layers.1.block.1.norm",
    "encoder.model.1.block.3.conv.norm": "encoder.layers.1.block.3.norm",
    "encoder.model.1.shortcut.conv.norm": "encoder.layers.1.shortcut.norm",
    "encoder.model.3.conv.norm": "encoder.layers.3.norm",
    "encoder.model.4.block.1.conv.norm": "encoder.layers.4.block.1.norm",
    "encoder.model.4.block.3.conv.norm": "encoder.layers.4.block.3.norm",
    "encoder.model.4.shortcut.conv.norm": "encoder.layers.4.shortcut.norm",
    "encoder.model.6.conv.norm": "encoder.layers.6.norm",
    "encoder.model.7.block.1.conv.norm": "encoder.layers.7.block.1.norm",
    "encoder.model.7.block.3.conv.norm": "encoder.layers.7.block.3.norm",
    "encoder.model.7.shortcut.conv.norm": "encoder.layers.7.shortcut.norm",
    "encoder.model.9.conv.norm": "encoder.layers.9.norm",
    "encoder.model.10.block.1.conv.norm": "encoder.layers.10.block.1.norm",
    "encoder.model.10.block.3.conv.norm": "encoder.layers.10.block.3.norm",
    "encoder.model.10.shortcut.conv.norm": "encoder.layers.10.shortcut.norm",
    "encoder.model.12.conv.norm": "encoder.layers.12.norm",
    "encoder.model.15.conv.norm": "encoder.layers.15.norm",
}
UpperCAmelCase_												=   {
    "decoder.model.0.conv.conv": "decoder.layers.0.conv",
    "decoder.model.1.lstm": "decoder.layers.1.lstm",
    "decoder.model.3.convtr.convtr": "decoder.layers.3.conv",
    "decoder.model.4.block.1.conv.conv": "decoder.layers.4.block.1.conv",
    "decoder.model.4.block.3.conv.conv": "decoder.layers.4.block.3.conv",
    "decoder.model.4.shortcut.conv.conv": "decoder.layers.4.shortcut.conv",
    "decoder.model.6.convtr.convtr": "decoder.layers.6.conv",
    "decoder.model.7.block.1.conv.conv": "decoder.layers.7.block.1.conv",
    "decoder.model.7.block.3.conv.conv": "decoder.layers.7.block.3.conv",
    "decoder.model.7.shortcut.conv.conv": "decoder.layers.7.shortcut.conv",
    "decoder.model.9.convtr.convtr": "decoder.layers.9.conv",
    "decoder.model.10.block.1.conv.conv": "decoder.layers.10.block.1.conv",
    "decoder.model.10.block.3.conv.conv": "decoder.layers.10.block.3.conv",
    "decoder.model.10.shortcut.conv.conv": "decoder.layers.10.shortcut.conv",
    "decoder.model.12.convtr.convtr": "decoder.layers.12.conv",
    "decoder.model.13.block.1.conv.conv": "decoder.layers.13.block.1.conv",
    "decoder.model.13.block.3.conv.conv": "decoder.layers.13.block.3.conv",
    "decoder.model.13.shortcut.conv.conv": "decoder.layers.13.shortcut.conv",
    "decoder.model.15.conv.conv": "decoder.layers.15.conv",
}
UpperCAmelCase_												=   {
    "decoder.model.0.conv.norm": "decoder.layers.0.norm",
    "decoder.model.3.convtr.norm": "decoder.layers.3.norm",
    "decoder.model.4.block.1.conv.norm": "decoder.layers.4.block.1.norm",
    "decoder.model.4.block.3.conv.norm": "decoder.layers.4.block.3.norm",
    "decoder.model.4.shortcut.conv.norm": "decoder.layers.4.shortcut.norm",
    "decoder.model.6.convtr.norm": "decoder.layers.6.norm",
    "decoder.model.7.block.1.conv.norm": "decoder.layers.7.block.1.norm",
    "decoder.model.7.block.3.conv.norm": "decoder.layers.7.block.3.norm",
    "decoder.model.7.shortcut.conv.norm": "decoder.layers.7.shortcut.norm",
    "decoder.model.9.convtr.norm": "decoder.layers.9.norm",
    "decoder.model.10.block.1.conv.norm": "decoder.layers.10.block.1.norm",
    "decoder.model.10.block.3.conv.norm": "decoder.layers.10.block.3.norm",
    "decoder.model.10.shortcut.conv.norm": "decoder.layers.10.shortcut.norm",
    "decoder.model.12.convtr.norm": "decoder.layers.12.norm",
    "decoder.model.13.block.1.conv.norm": "decoder.layers.13.block.1.norm",
    "decoder.model.13.block.3.conv.norm": "decoder.layers.13.block.3.norm",
    "decoder.model.13.shortcut.conv.norm": "decoder.layers.13.shortcut.norm",
    "decoder.model.15.conv.norm": "decoder.layers.15.norm",
}
UpperCAmelCase_												=   {
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
UpperCAmelCase_												=   {
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
UpperCAmelCase_												=   []
UpperCAmelCase_												=   []

def  _UpperCamelCase   (					SCREAMING_SNAKE_CASE__      :   str							,    SCREAMING_SNAKE_CASE__      :   Any							,    SCREAMING_SNAKE_CASE__      :   List[Any]							,    SCREAMING_SNAKE_CASE__      :   int							,    SCREAMING_SNAKE_CASE__      :   Any							):
 '''simple docstring'''





 for attribute in key.split("""."""							):
  UpperCAmelCase__      				=     getattr(__lowercase							,    __lowercase							)

 if weight_type is not None:
  UpperCAmelCase__      				=     getattr(__lowercase							,    __lowercase							).shape
 else:
  UpperCAmelCase__      				=     hf_pointer.shape

 if hf_shape != value.shape:
  raise ValueError(
      F'''Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be'''
      F''' {value.shape} for {full_name}'''							)

 if weight_type == "weight":
  UpperCAmelCase__      				=     value
 elif weight_type == "weight_g":
  UpperCAmelCase__      				=     value
 elif weight_type == "weight_v":
  UpperCAmelCase__      				=     value
 elif weight_type == "bias":
  UpperCAmelCase__      				=     value
 elif weight_type == "running_mean":
  UpperCAmelCase__      				=     value
 elif weight_type == "running_var":
  UpperCAmelCase__      				=     value
 elif weight_type == "num_batches_tracked":
  UpperCAmelCase__      				=     value
 elif weight_type == "weight_ih_l0":
  UpperCAmelCase__      				=     value
 elif weight_type == "weight_hh_l0":
  UpperCAmelCase__      				=     value
 elif weight_type == "bias_ih_l0":
  UpperCAmelCase__      				=     value
 elif weight_type == "bias_hh_l0":
  UpperCAmelCase__      				=     value
 elif weight_type == "weight_ih_l1":
  UpperCAmelCase__      				=     value
 elif weight_type == "weight_hh_l1":
  UpperCAmelCase__      				=     value
 elif weight_type == "bias_ih_l1":
  UpperCAmelCase__      				=     value
 elif weight_type == "bias_hh_l1":
  UpperCAmelCase__      				=     value
 else:
  UpperCAmelCase__      				=     value

 logger.info(F'''{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.'''							)

def  _UpperCamelCase   (					SCREAMING_SNAKE_CASE__      :   Optional[Any]							,    SCREAMING_SNAKE_CASE__      :   Optional[int]							):
 '''simple docstring'''





 for key in ignore_keys:
  if key.endswith(""".*"""							):
   if name.startswith(key[:-1]							):
    return True
  elif ".*." in key:
   UpperCAmelCase__				,      UpperCAmelCase__      				=     key.split(""".*."""							)
   if prefix in name and suffix in name:
    return True
  elif key in name:
   return True
 return False

def  _UpperCamelCase   (					SCREAMING_SNAKE_CASE__      :   List[str]							,    SCREAMING_SNAKE_CASE__      :   List[str]							,    SCREAMING_SNAKE_CASE__      :   List[str]							):
 '''simple docstring'''





 UpperCAmelCase__      				=     []

 if model_name == "encodec_24khz" or "encodec_32khz":
  UpperCAmelCase__      				=     MAPPING_24K
 elif model_name == "encodec_48khz":
  UpperCAmelCase__      				=     MAPPING_48K
 else:
  raise ValueError(F'''Unsupported model: {model_name}'''							)

 for name, value in orig_dict.items():
  if should_ignore(__lowercase							,    __lowercase							):
   logger.info(F'''{name} was ignored'''							)
   continue

  UpperCAmelCase__      				=     False
  for key, mapped_key in MAPPING.items():
   if "*" in key:
    UpperCAmelCase__				,      UpperCAmelCase__      				=     key.split(""".*."""							)
    if prefix in name and suffix in name:
     UpperCAmelCase__      				=     suffix

   if key in name:
    # HACK otherwise .embed gets initialized with .embed_avg too
    if key.endswith("""embed"""							) and name.endswith("""embed_avg"""							):
     continue

    UpperCAmelCase__      				=     True
    if "*" in mapped_key:
     UpperCAmelCase__      				=     name.split(__lowercase							)[0].split("""."""							)[-2]
     UpperCAmelCase__      				=     mapped_key.replace("""*"""							,    __lowercase							)
    if "weight_g" in name:
     UpperCAmelCase__      				=     """weight_g"""
    elif "weight_v" in name:
     UpperCAmelCase__      				=     """weight_v"""
    elif "weight_ih_l0" in name:
     UpperCAmelCase__      				=     """weight_ih_l0"""
    elif "weight_hh_l0" in name:
     UpperCAmelCase__      				=     """weight_hh_l0"""
    elif "bias_ih_l0" in name:
     UpperCAmelCase__      				=     """bias_ih_l0"""
    elif "bias_hh_l0" in name:
     UpperCAmelCase__      				=     """bias_hh_l0"""
    elif "weight_ih_l1" in name:
     UpperCAmelCase__      				=     """weight_ih_l1"""
    elif "weight_hh_l1" in name:
     UpperCAmelCase__      				=     """weight_hh_l1"""
    elif "bias_ih_l1" in name:
     UpperCAmelCase__      				=     """bias_ih_l1"""
    elif "bias_hh_l1" in name:
     UpperCAmelCase__      				=     """bias_hh_l1"""
    elif "bias" in name:
     UpperCAmelCase__      				=     """bias"""
    elif "weight" in name:
     UpperCAmelCase__      				=     """weight"""
    elif "running_mean" in name:
     UpperCAmelCase__      				=     """running_mean"""
    elif "running_var" in name:
     UpperCAmelCase__      				=     """running_var"""
    elif "num_batches_tracked" in name:
     UpperCAmelCase__      				=     """num_batches_tracked"""
    else:
     UpperCAmelCase__      				=     None
    set_recursively(__lowercase							,    __lowercase							,    __lowercase							,    __lowercase							,    __lowercase							)
   continue
  if not is_used:
   unused_weights.append(__lowercase							)

 logger.warning(F'''Unused weights: {unused_weights}'''							)

@torch.no_grad()
def  _UpperCamelCase   (					SCREAMING_SNAKE_CASE__      :   Any							,    SCREAMING_SNAKE_CASE__      :   Tuple							,    SCREAMING_SNAKE_CASE__      :   int							,    SCREAMING_SNAKE_CASE__      :   int=None							,    SCREAMING_SNAKE_CASE__      :   Optional[Any]=None							,    ):
 '''simple docstring'''





 if config_path is not None:
  UpperCAmelCase__      				=     EncodecConfig.from_pretrained(__lowercase							)
 else:
  UpperCAmelCase__      				=     EncodecConfig()

 if model_name == "encodec_24khz":
  pass  # config is already correct
 elif model_name == "encodec_32khz":
  UpperCAmelCase__      				=     [8, 5, 4, 4]
  UpperCAmelCase__      				=     [2.2]
  UpperCAmelCase__      				=     64
  UpperCAmelCase__      				=     32000
  UpperCAmelCase__      				=     2048
  UpperCAmelCase__      				=     False
  UpperCAmelCase__      				=     False
  UpperCAmelCase__      				=     False
 elif model_name == "encodec_48khz":
  UpperCAmelCase__      				=     [8, 5, 4, 2]
  UpperCAmelCase__      				=     [3.0, 6.0, 12.0, 24.0]
  UpperCAmelCase__      				=     48000
  UpperCAmelCase__      				=     2
  UpperCAmelCase__      				=     False
  UpperCAmelCase__      				=     """time_group_norm"""
  UpperCAmelCase__      				=     True
  UpperCAmelCase__      				=     1.0
  UpperCAmelCase__      				=     0.01
 else:
  raise ValueError(F'''Unknown model name: {model_name}'''							)

 UpperCAmelCase__      				=     EncodecModel(__lowercase							)

 UpperCAmelCase__      				=     EncodecFeatureExtractor(
     feature_size=config.audio_channels							,    sampling_rate=config.sampling_rate							,    chunk_length_s=config.chunk_length_s							,    overlap=config.overlap							,    )
 feature_extractor.save_pretrained(__lowercase							)

 UpperCAmelCase__      				=     torch.load(__lowercase							)
 if "best_state" in original_checkpoint:
  # we might have a training state saved, in which case discard the yaml results and just retain the weights
  UpperCAmelCase__      				=     original_checkpoint["""best_state"""]
 recursively_load_weights(__lowercase							,    __lowercase							,    __lowercase							)
 model.save_pretrained(__lowercase							)

 if repo_id:
  print("""Pushing to the hub..."""							)
  feature_extractor.push_to_hub(__lowercase							)
  model.push_to_hub(__lowercase							)


if __name__ == "__main__":
    UpperCAmelCase_												=   argparse.ArgumentParser()
    parser.add_argument(
        '--model',
        default='encodec_24khz',
        type=str,
        help='The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.',
    )
    parser.add_argument('--checkpoint_path', required=True, default=None, type=str, help='Path to original checkpoint')
    parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
    parser.add_argument(
        '--pytorch_dump_folder_path', required=True, default=None, type=str, help='Path to the output PyTorch model.'
    )
    parser.add_argument(
        '--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
    )

    UpperCAmelCase_												=   parser.parse_args()
    convert_checkpoint(
        args.model,
        args.checkpoint_path,
        args.pytorch_dump_folder_path,
        args.config_path,
        args.push_to_hub,
    )








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







     '''simple docstring'''




     def 		lowerCAmelCase_  (					self							:      int					):


         """simple docstring"""



         __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(UpperCamelCase_			,						exist_ok=UpperCamelCase_					)
         __A       =						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]					)					)

         __A       =						os.path.join(self.tmpdirname			,						"""realm_block_records"""					)
         os.makedirs(UpperCamelCase_			,						exist_ok=UpperCamelCase_					)




     def 		lowerCAmelCase_  (					self							:      List[Any]					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      Union[str, Any]					):


         """simple docstring"""



         shutil.rmtree(self.tmpdirname					)




     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         __A       =						RealmConfig(num_block_records=self.num_block_records					)
         return config




     def 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         __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=UpperCamelCase_			,						)
         return block_records




     def 		lowerCAmelCase_  (					self							:      List[Any]					):


         """simple docstring"""



         __A       =						RealmRetriever(
             block_records=self.get_dummy_block_records()			,						tokenizer=self.get_tokenizer()			,						)
         return retriever




     def 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



         __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=UpperCamelCase_			,						return_token_type_ids=UpperCamelCase_			,						return_attention_mask=UpperCamelCase_			,						).input_ids
         __A       =						config.reader_seq_len

         __A     ,						__A     ,						__A     ,						__A       =						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					):


         """simple docstring"""



         __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=UpperCamelCase_			,						return_token_type_ids=UpperCamelCase_			,						return_attention_mask=UpperCamelCase_			,						).input_ids
         __A       =						config.reader_seq_len

         __A     ,						__A     ,						__A     ,						__A       =						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					):


         """simple docstring"""



         __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"""					)




