




'''simple docstring'''


import argparse

import torch

from diffusers import UNetaDConditionModel



def    _SCREAMING_SNAKE_CASE    (			UpperCamelCase__						:				Optional[Any]   ,						UpperCamelCase__						:				str   ,						UpperCamelCase__						:				Any   ,						UpperCamelCase__						:				Dict=None   ,						UpperCamelCase__						:				str=None   ,						UpperCamelCase__						:				int=None							):




     """simple docstring"""


     assert isinstance(_A   ,						_A							), "Paths should be a list of dicts containing 'old' and 'new' keys."

     # Splits the attention layers into three variables.
     if attention_paths_to_split is not None:
          for path, path_map in attention_paths_to_split.items():
               a_    :       Union[str, Any]    	=     old_checkpoint[path]
               a_    :       List[str]    	=     old_tensor.shape[0] // 3

               a_    :       Tuple    	=     (-1, channels) if len(old_tensor.shape							) == 3 else (-1)

               a_    :       Any    	=     old_tensor.shape[0] // config["""num_head_channels"""] // 3

               a_    :       str    	=     old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]							)
               a_	,    a_	,    a_    :       Dict    	=     old_tensor.split(channels // num_heads   ,						dim=1							)

               a_    :       Tuple    	=     query.reshape(_A							)
               a_    :       List[str]    	=     key.reshape(_A							)
               a_    :       Optional[Any]    	=     value.reshape(_A							)

     for path in paths:
          a_    :       str    	=     path["""new"""]

          # These have already been assigned
          if attention_paths_to_split is not None and new_path in attention_paths_to_split:
               continue

          if additional_replacements is not None:
               for replacement in additional_replacements:
                    a_    :       List[str]    	=     new_path.replace(replacement["""old"""]   ,						replacement["""new"""]							)

                    # proj_attn.weight has to be converted from conv 1D to linear
          a_    :       str    	=     old_checkpoint[path["""old"""]]
          a_    :       Dict    	=     ["""proj_attn.weight"""]
          a_    :       str    	=     ["""proj_out.weight""", """proj_in.weight"""]
          if any(k in new_path for k in names							):
               a_    :       str    	=     weight[:, :, 0]
          elif any(k in new_path for k in names_a							) and len(weight.shape							) > 2 and ".attentions." not in new_path:
               a_    :       List[Any]    	=     weight[:, :, 0]
          else:
               a_    :       List[Any]    	=     weight



def    _SCREAMING_SNAKE_CASE    (			UpperCamelCase__						:				Optional[Any]   ,						UpperCamelCase__						:				Optional[int]=0							):




     """simple docstring"""


     a_    :       int    	=     []
     for old_item in old_list:
          a_    :       Optional[Any]    	=     old_item

          #         new_item = new_item.replace('norm.weight', 'group_norm.weight')
          #         new_item = new_item.replace('norm.bias', 'group_norm.bias')

          #         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
          #         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

          #         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

          mapping.append({"""old""": old_item, """new""": new_item}							)

     return mapping



def    _SCREAMING_SNAKE_CASE    (			UpperCamelCase__						:				Optional[Any]   ,						UpperCamelCase__						:				List[str]=1							):




     """simple docstring"""


     if n_shave_prefix_segments >= 0:
          return ".".join(path.split("""."""							)[n_shave_prefix_segments:]							)
     else:
          return ".".join(path.split("""."""							)[:n_shave_prefix_segments]							)



def    _SCREAMING_SNAKE_CASE    (			UpperCamelCase__						:				Union[str, Any]   ,						UpperCamelCase__						:				Optional[int]=0							):




     """simple docstring"""


     a_    :       Tuple    	=     []
     for old_item in old_list:
          mapping.append({"""old""": old_item, """new""": old_item}							)

     return mapping



def    _SCREAMING_SNAKE_CASE    (			UpperCamelCase__						:				Optional[int]   ,						UpperCamelCase__						:				Union[str, Any]=0							):




     """simple docstring"""


     a_    :       Tuple    	=     []
     for old_item in old_list:
          a_    :       Union[str, Any]    	=     old_item.replace("""in_layers.0"""   ,						"""norm1"""							)
          a_    :       Tuple    	=     new_item.replace("""in_layers.2"""   ,						"""conv1"""							)

          a_    :       Optional[Any]    	=     new_item.replace("""out_layers.0"""   ,						"""norm2"""							)
          a_    :       Union[str, Any]    	=     new_item.replace("""out_layers.3"""   ,						"""conv2"""							)

          a_    :       List[Any]    	=     new_item.replace("""emb_layers.1"""   ,						"""time_emb_proj"""							)
          a_    :       Any    	=     new_item.replace("""skip_connection"""   ,						"""conv_shortcut"""							)

          a_    :       Any    	=     shave_segments(_A   ,						n_shave_prefix_segments=_A							)

          if "temopral_conv" not in old_item:
               mapping.append({"""old""": old_item, """new""": new_item}							)

     return mapping



def    _SCREAMING_SNAKE_CASE    (			UpperCamelCase__						:				str   ,						UpperCamelCase__						:				int   ,						UpperCamelCase__						:				Tuple=None   ,						UpperCamelCase__						:				str=False							):




     """simple docstring"""


     a_    :       Optional[int]    	=     {}
     a_    :       Optional[Any]    	=     list(checkpoint.keys()							)

     a_    :       int    	=     """model.diffusion_model."""

     # at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
     if sum(k.startswith("""model_ema"""							) for k in keys							) > 100 and extract_ema:
          print(F"Checkpoint {path} has both EMA and non-EMA weights."							)
          print(
              """In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"""
              """ weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag."""							)
          for key in keys:
               if key.startswith("""model.diffusion_model"""							):
                    a_    :       Any    	=     """model_ema.""" + """""".join(key.split("""."""							)[1:]							)
                    a_    :       List[Any]    	=     checkpoint.pop(_A							)
     else:
          if sum(k.startswith("""model_ema"""							) for k in keys							) > 100:
               print(
                   """In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"""
                   """ weights (usually better for inference), please make sure to add the `--extract_ema` flag."""							)

          for key in keys:
               a_    :       List[str]    	=     checkpoint.pop(_A							)

     a_    :       Union[str, Any]    	=     {}

     a_    :       str    	=     unet_state_dict["""time_embed.0.weight"""]
     a_    :       Union[str, Any]    	=     unet_state_dict["""time_embed.0.bias"""]
     a_    :       Union[str, Any]    	=     unet_state_dict["""time_embed.2.weight"""]
     a_    :       Tuple    	=     unet_state_dict["""time_embed.2.bias"""]

     if config["class_embed_type"] is None:
          # No parameters to port
          ...
     elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
          a_    :       Optional[int]    	=     unet_state_dict["""label_emb.0.0.weight"""]
          a_    :       Any    	=     unet_state_dict["""label_emb.0.0.bias"""]
          a_    :       Tuple    	=     unet_state_dict["""label_emb.0.2.weight"""]
          a_    :       Any    	=     unet_state_dict["""label_emb.0.2.bias"""]
     else:
          raise NotImplementedError(F"Not implemented `class_embed_type`: {config['class_embed_type']}"							)

     a_    :       Optional[int]    	=     unet_state_dict["""input_blocks.0.0.weight"""]
     a_    :       Any    	=     unet_state_dict["""input_blocks.0.0.bias"""]

     a_    :       Tuple    	=     [v for v in unet_state_dict if v.startswith("""input_blocks.0.1"""							)]
     a_    :       Any    	=     renew_attention_paths(_A							)
     a_    :       Dict    	=     {"""old""": """input_blocks.0.1""", """new""": """transformer_in"""}
     assign_to_checkpoint(_A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

     a_    :       Optional[Any]    	=     unet_state_dict["""out.0.weight"""]
     a_    :       str    	=     unet_state_dict["""out.0.bias"""]
     a_    :       List[Any]    	=     unet_state_dict["""out.2.weight"""]
     a_    :       List[Any]    	=     unet_state_dict["""out.2.bias"""]

     # Retrieves the keys for the input blocks only
     a_    :       Optional[int]    	=     len({""".""".join(layer.split("""."""							)[:2]							) for layer in unet_state_dict if """input_blocks""" in layer}							)
     a_    :       Optional[Any]    	=     {
         layer_id: [key for key in unet_state_dict if F"input_blocks.{layer_id}" in key]
         for layer_id in range(_A							)
     }

     # Retrieves the keys for the middle blocks only
     a_    :       List[Any]    	=     len({""".""".join(layer.split("""."""							)[:2]							) for layer in unet_state_dict if """middle_block""" in layer}							)
     a_    :       Optional[int]    	=     {
         layer_id: [key for key in unet_state_dict if F"middle_block.{layer_id}" in key]
         for layer_id in range(_A							)
     }

     # Retrieves the keys for the output blocks only
     a_    :       Any    	=     len({""".""".join(layer.split("""."""							)[:2]							) for layer in unet_state_dict if """output_blocks""" in layer}							)
     a_    :       Union[str, Any]    	=     {
         layer_id: [key for key in unet_state_dict if F"output_blocks.{layer_id}" in key]
         for layer_id in range(_A							)
     }

     for i in range(1   ,						_A							):
          a_    :       str    	=     (i - 1) // (config["""layers_per_block"""] + 1)
          a_    :       Tuple    	=     (i - 1) % (config["""layers_per_block"""] + 1)

          a_    :       str    	=     [
              key for key in input_blocks[i] if F"input_blocks.{i}.0" in key and F"input_blocks.{i}.0.op" not in key
          ]
          a_    :       Union[str, Any]    	=     [key for key in input_blocks[i] if F"input_blocks.{i}.1" in key]
          a_    :       List[Any]    	=     [key for key in input_blocks[i] if F"input_blocks.{i}.2" in key]

          if F"input_blocks.{i}.op.weight" in unet_state_dict:
               a_    :       Tuple    	=     unet_state_dict.pop(
                   F"input_blocks.{i}.op.weight"							)
               a_    :       List[Any]    	=     unet_state_dict.pop(
                   F"input_blocks.{i}.op.bias"							)

          a_    :       Tuple    	=     renew_resnet_paths(_A							)
          a_    :       Optional[Any]    	=     {"""old""": F"input_blocks.{i}.0", """new""": F"down_blocks.{block_id}.resnets.{layer_in_block_id}"}
          assign_to_checkpoint(
              _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

          a_    :       str    	=     [key for key in resnets if """temopral_conv""" in key]
          a_    :       Union[str, Any]    	=     renew_temp_conv_paths(_A							)
          a_    :       Optional[Any]    	=     {
              """old""": F"input_blocks.{i}.0.temopral_conv",
              """new""": F"down_blocks.{block_id}.temp_convs.{layer_in_block_id}",
          }
          assign_to_checkpoint(
              _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

          if len(_A							):
               a_    :       Dict    	=     renew_attention_paths(_A							)
               a_    :       Optional[Any]    	=     {"""old""": F"input_blocks.{i}.1", """new""": F"down_blocks.{block_id}.attentions.{layer_in_block_id}"}
               assign_to_checkpoint(
                   _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

          if len(_A							):
               a_    :       Dict    	=     renew_attention_paths(_A							)
               a_    :       Optional[Any]    	=     {
                   """old""": F"input_blocks.{i}.2",
                   """new""": F"down_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
               }
               assign_to_checkpoint(
                   _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

     a_    :       Any    	=     middle_blocks[0]
     a_    :       List[Any]    	=     [key for key in resnet_a if """temopral_conv""" in key]
     a_    :       List[Any]    	=     middle_blocks[1]
     a_    :       Optional[int]    	=     middle_blocks[2]
     a_    :       Dict    	=     middle_blocks[3]
     a_    :       Any    	=     [key for key in resnet_a if """temopral_conv""" in key]

     a_    :       int    	=     renew_resnet_paths(_A							)
     a_    :       Tuple    	=     {"""old""": """middle_block.0""", """new""": """mid_block.resnets.0"""}
     assign_to_checkpoint(
         _A   ,						_A   ,						_A   ,						config=_A   ,						additional_replacements=[meta_path]							)

     a_    :       Dict    	=     renew_temp_conv_paths(_A							)
     a_    :       Optional[int]    	=     {"""old""": """middle_block.0.temopral_conv""", """new""": """mid_block.temp_convs.0"""}
     assign_to_checkpoint(
         _A   ,						_A   ,						_A   ,						config=_A   ,						additional_replacements=[meta_path]							)

     a_    :       Optional[int]    	=     renew_resnet_paths(_A							)
     a_    :       Any    	=     {"""old""": """middle_block.3""", """new""": """mid_block.resnets.1"""}
     assign_to_checkpoint(
         _A   ,						_A   ,						_A   ,						config=_A   ,						additional_replacements=[meta_path]							)

     a_    :       Any    	=     renew_temp_conv_paths(_A							)
     a_    :       Any    	=     {"""old""": """middle_block.3.temopral_conv""", """new""": """mid_block.temp_convs.1"""}
     assign_to_checkpoint(
         _A   ,						_A   ,						_A   ,						config=_A   ,						additional_replacements=[meta_path]							)

     a_    :       Tuple    	=     renew_attention_paths(_A							)
     a_    :       int    	=     {"""old""": """middle_block.1""", """new""": """mid_block.attentions.0"""}
     assign_to_checkpoint(
         _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

     a_    :       int    	=     renew_attention_paths(_A							)
     a_    :       Optional[int]    	=     {"""old""": """middle_block.2""", """new""": """mid_block.temp_attentions.0"""}
     assign_to_checkpoint(
         _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

     for i in range(_A							):
          a_    :       List[str]    	=     i // (config["""layers_per_block"""] + 1)
          a_    :       Tuple    	=     i % (config["""layers_per_block"""] + 1)
          a_    :       Dict    	=     [shave_segments(_A   ,						2							) for name in output_blocks[i]]
          a_    :       str    	=     {}

          for layer in output_block_layers:
               a_	,    a_    :       Optional[int]    	=     layer.split("""."""							)[0], shave_segments(_A   ,						1							)
               if layer_id in output_block_list:
                    output_block_list[layer_id].append(_A							)
               else:
                    a_    :       Optional[int]    	=     [layer_name]

          if len(_A							) > 1:
               a_    :       int    	=     [key for key in output_blocks[i] if F"output_blocks.{i}.0" in key]
               a_    :       Optional[int]    	=     [key for key in output_blocks[i] if F"output_blocks.{i}.1" in key]
               a_    :       List[str]    	=     [key for key in output_blocks[i] if F"output_blocks.{i}.2" in key]

               a_    :       Tuple    	=     renew_resnet_paths(_A							)
               a_    :       int    	=     renew_resnet_paths(_A							)

               a_    :       Tuple    	=     {"""old""": F"output_blocks.{i}.0", """new""": F"up_blocks.{block_id}.resnets.{layer_in_block_id}"}
               assign_to_checkpoint(
                   _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

               a_    :       Optional[int]    	=     [key for key in resnets if """temopral_conv""" in key]
               a_    :       int    	=     renew_temp_conv_paths(_A							)
               a_    :       Dict    	=     {
                   """old""": F"output_blocks.{i}.0.temopral_conv",
                   """new""": F"up_blocks.{block_id}.temp_convs.{layer_in_block_id}",
               }
               assign_to_checkpoint(
                   _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

               a_    :       List[Any]    	=     {k: sorted(_A							) for k, v in output_block_list.items()}
               if ["conv.bias", "conv.weight"] in output_block_list.values():
                    a_    :       Optional[Any]    	=     list(output_block_list.values()							).index(["""conv.bias""", """conv.weight"""]							)
                    a_    :       List[str]    	=     unet_state_dict[
                        F"output_blocks.{i}.{index}.conv.weight"
                    ]
                    a_    :       Optional[int]    	=     unet_state_dict[
                        F"output_blocks.{i}.{index}.conv.bias"
                    ]

                    # Clear attentions as they have been attributed above.
                    if len(_A							) == 2:
                         a_    :       Optional[Any]    	=     []

               if len(_A							):
                    a_    :       Optional[int]    	=     renew_attention_paths(_A							)
                    a_    :       Any    	=     {
                        """old""": F"output_blocks.{i}.1",
                        """new""": F"up_blocks.{block_id}.attentions.{layer_in_block_id}",
                    }
                    assign_to_checkpoint(
                        _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)

               if len(_A							):
                    a_    :       Tuple    	=     renew_attention_paths(_A							)
                    a_    :       List[Any]    	=     {
                        """old""": F"output_blocks.{i}.2",
                        """new""": F"up_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
                    }
                    assign_to_checkpoint(
                        _A   ,						_A   ,						_A   ,						additional_replacements=[meta_path]   ,						config=_A							)
          else:
               a_    :       Any    	=     renew_resnet_paths(_A   ,						n_shave_prefix_segments=1							)
               for path in resnet_0_paths:
                    a_    :       Tuple    	=     """.""".join(["""output_blocks""", str(_A							), path["""old"""]]							)
                    a_    :       List[str]    	=     """.""".join(["""up_blocks""", str(_A							), """resnets""", str(_A							), path["""new"""]]							)
                    a_    :       Any    	=     unet_state_dict[old_path]

               a_    :       Tuple    	=     [l for l in output_block_layers if """temopral_conv""" in l]
               for path in temopral_conv_paths:
                    a_    :       Optional[Any]    	=     path.split("""temopral_conv."""							)[-1]
                    a_    :       Union[str, Any]    	=     """.""".join(["""output_blocks""", str(_A							), str(_A							), """temopral_conv""", pruned_path]							)
                    a_    :       List[str]    	=     """.""".join(["""up_blocks""", str(_A							), """temp_convs""", str(_A							), pruned_path]							)
                    a_    :       Optional[Any]    	=     unet_state_dict[old_path]

     return new_checkpoint


if __name__ == "__main__":
    lowerCAmelCase_			:     List[str]							    =     argparse.ArgumentParser()

    parser.add_argument(
        '--checkpoint_path', default=None, type=str, required=True, help='Path to the checkpoint to convert.'
    )
    parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')
    lowerCAmelCase_			:     Tuple							    =     parser.parse_args()

    lowerCAmelCase_			:     List[str]							    =     torch.load(args.checkpoint_path, map_location='cpu')
    lowerCAmelCase_			:     Optional[int]							    =     UNetaDConditionModel()

    lowerCAmelCase_			:     Union[str, Any]							    =     convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

    lowerCAmelCase_			:     Optional[int]							    =     set(unet.state_dict().keys()) - set(converted_ckpt.keys())
    lowerCAmelCase_			:     Dict							    =     set(converted_ckpt.keys()) - set(unet.state_dict().keys())

    assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

    # load state_dict
    unet.load_state_dict(converted_ckpt)

    unet.save_pretrained(args.dump_path)

    # -- finish converting the unet --






'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase_			:     int							    =     {
    'configuration_dpr': ['DPR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DPRConfig'],
    'tokenization_dpr': [
        'DPRContextEncoderTokenizer',
        'DPRQuestionEncoderTokenizer',
        'DPRReaderOutput',
        'DPRReaderTokenizer',
    ],
}


try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase_			:     Union[str, Any]							    =     [
     'DPRContextEncoderTokenizerFast',
     'DPRQuestionEncoderTokenizerFast',
     'DPRReaderTokenizerFast',
 ]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase_			:     List[str]							    =     [
     'DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DPRContextEncoder',
     'DPRPretrainedContextEncoder',
     'DPRPreTrainedModel',
     'DPRPretrainedQuestionEncoder',
     'DPRPretrainedReader',
     'DPRQuestionEncoder',
     'DPRReader',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase_			:     Dict							    =     [
     'TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFDPRContextEncoder',
     'TFDPRPretrainedContextEncoder',
     'TFDPRPretrainedQuestionEncoder',
     'TFDPRPretrainedReader',
     'TFDPRQuestionEncoder',
     'TFDPRReader',
 ]


if TYPE_CHECKING:
 from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
 from .tokenization_dpr import (
     DPRContextEncoderTokenizer,
     DPRQuestionEncoderTokenizer,
     DPRReaderOutput,
     DPRReaderTokenizer,
 )

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_dpr_fast import (
      DPRContextEncoderTokenizerFast,
      DPRQuestionEncoderTokenizerFast,
      DPRReaderTokenizerFast,
  )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_dpr import (
      DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
      DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
      DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
      DPRContextEncoder,
      DPRPretrainedContextEncoder,
      DPRPreTrainedModel,
      DPRPretrainedQuestionEncoder,
      DPRPretrainedReader,
      DPRQuestionEncoder,
      DPRReader,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_dpr import (
      TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
      TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
      TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFDPRContextEncoder,
      TFDPRPretrainedContextEncoder,
      TFDPRPretrainedQuestionEncoder,
      TFDPRPretrainedReader,
      TFDPRQuestionEncoder,
      TFDPRReader,
  )

else:
 import sys

 lowerCAmelCase_			:     int							    =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
