code: 
  
  import argparse
  import json
  
  import torch
  
  from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNetaDModel, VQModel
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Any			,   _A   :				Tuple=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     UpperCAmelCase__       (    _A   :				Dict			,   _A   :				Optional[int]=0							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=[]
    for old_item in old_list:
      a__						=old_item
      a__						=new_item.replace('''block.'''			,   '''resnets.'''							)
      a__						=new_item.replace('''conv_shorcut'''			,   '''conv1'''							)
      a__						=new_item.replace('''in_shortcut'''			,   '''conv_shortcut'''							)
      a__						=new_item.replace('''temb_proj'''			,   '''time_emb_proj'''							)
  
      a__						=shave_segments(_A			,   n_shave_prefix_segments=_A							)
  
      mapping.append({'''old''': old_item, '''new''': new_item}							)
  
    return mapping
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Union[str, Any]			,   _A   :				Tuple=0			,   _A   :				Any=False							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						=[]
    for old_item in old_list:
      a__						=old_item
  
      # In `model.mid`, the layer is called `attn`.
      if not in_mid:
        a__						=new_item.replace('''attn'''			,   '''attentions'''							)
      a__						=new_item.replace('''.k.'''			,   '''.key.'''							)
      a__						=new_item.replace('''.v.'''			,   '''.value.'''							)
      a__						=new_item.replace('''.q.'''			,   '''.query.'''							)
  
      a__						=new_item.replace('''proj_out'''			,   '''proj_attn'''							)
      a__						=new_item.replace('''norm'''			,   '''group_norm'''							)
  
      a__						=shave_segments(_A			,   n_shave_prefix_segments=_A							)
      mapping.append({'''old''': old_item, '''new''': new_item}							)
  
    return mapping
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				List[str]			,   _A   :				Any			,   _A   :				Tuple			,   _A   :				Optional[Any]=None			,   _A   :				Tuple=None			,   _A   :				List[str]=None							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    assert isinstance(_A			,   _A							), "Paths should be a list of dicts containing 'old' and 'new' keys."
  
    if attention_paths_to_split is not None:
      if config is None:
        raise ValueError('''Please specify the config if setting \'attention_paths_to_split\' to \'True\'.'''							)
  
      for path, path_map in attention_paths_to_split.items():
        a__						=old_checkpoint[path]
        a__						=old_tensor.shape[0] // 3
  
        a__						=(-1, channels) if len(old_tensor.shape							) == 3 else (-1)
  
        a__						=old_tensor.shape[0] // config.get('''num_head_channels'''			,   1							) // 3
  
        a__						=old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]							)
        a__,   a__,   a__						=old_tensor.split(channels // num_heads			,   dim=1							)
  
        a__						=query.reshape(_A							).squeeze()
        a__						=key.reshape(_A							).squeeze()
        a__						=value.reshape(_A							).squeeze()
  
    for path in paths:
      a__						=path['''new''']
  
      if attention_paths_to_split is not None and new_path in attention_paths_to_split:
        continue
  
      a__						=new_path.replace('''down.'''			,   '''down_blocks.'''							)
      a__						=new_path.replace('''up.'''			,   '''up_blocks.'''							)
  
      if additional_replacements is not None:
        for replacement in additional_replacements:
          a__						=new_path.replace(replacement['''old''']			,   replacement['''new''']							)
  
      if "attentions" in new_path:
        a__						=old_checkpoint[path['''old''']].squeeze()
      else:
        a__						=old_checkpoint[path['''old''']]
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Optional[int]			,   _A   :				Optional[int]							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						={}
  
    a__						=checkpoint['''temb.dense.0.weight''']
    a__						=checkpoint['''temb.dense.0.bias''']
    a__						=checkpoint['''temb.dense.1.weight''']
    a__						=checkpoint['''temb.dense.1.bias''']
  
    a__						=checkpoint['''norm_out.weight''']
    a__						=checkpoint['''norm_out.bias''']
  
    a__						=checkpoint['''conv_in.weight''']
    a__						=checkpoint['''conv_in.bias''']
    a__						=checkpoint['''conv_out.weight''']
    a__						=checkpoint['''conv_out.bias''']
  
    a__						=len({'''.'''.join(layer.split('''.'''							)[:2]							) for layer in checkpoint if '''down''' in layer}							)
    a__						={
        layer_id: [key for key in checkpoint if F"""down.{layer_id}""" in key] for layer_id in range(_A							)
    }
  
    a__						=len({'''.'''.join(layer.split('''.'''							)[:2]							) for layer in checkpoint if '''up''' in layer}							)
    a__						={layer_id: [key for key in checkpoint if F"""up.{layer_id}""" in key] for layer_id in range(_A							)}
  
    for i in range(_A							):
      a__						=(i - 1) // (config['''layers_per_block'''] + 1)
  
      if any('''downsample''' in layer for layer in down_blocks[i]							):
        a__						=checkpoint[
            F"""down.{i}.downsample.op.weight"""
        ]
        a__						=checkpoint[F"""down.{i}.downsample.op.bias"""]
      #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.weight'] = checkpoint[f'down.{i}.downsample.conv.weight']
      #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.bias'] = checkpoint[f'down.{i}.downsample.conv.bias']
  
      if any('''block''' in layer for layer in down_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   2							).split('''.'''							)[:2]							) for layer in down_blocks[i] if '''block''' in layer}							)
        a__						={
            layer_id: [key for key in down_blocks[i] if F"""block.{layer_id}""" in key]
            for layer_id in range(_A							)
        }
  
        if num_blocks > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_resnet_paths(blocks[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A							)
  
      if any('''attn''' in layer for layer in down_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   2							).split('''.'''							)[:2]							) for layer in down_blocks[i] if '''attn''' in layer}							)
        a__						={
            layer_id: [key for key in down_blocks[i] if F"""attn.{layer_id}""" in key]
            for layer_id in range(_A							)
        }
  
        if num_attn > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_attention_paths(attns[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   config=_A							)
  
    a__						=[key for key in checkpoint if '''mid.block_1''' in key]
    a__						=[key for key in checkpoint if '''mid.block_2''' in key]
    a__						=[key for key in checkpoint if '''mid.attn_1''' in key]
  
    # Mid new 2
    a__						=renew_resnet_paths(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]			,   )
  
    a__						=renew_resnet_paths(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]			,   )
  
    a__						=renew_attention_paths(_A			,   in_mid=_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''attn_1''', '''new''': '''attentions.0'''}]			,   )
  
    for i in range(_A							):
      a__						=num_up_blocks - 1 - i
  
      if any('''upsample''' in layer for layer in up_blocks[i]							):
        a__						=checkpoint[
            F"""up.{i}.upsample.conv.weight"""
        ]
        a__						=checkpoint[F"""up.{i}.upsample.conv.bias"""]
  
      if any('''block''' in layer for layer in up_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   2							).split('''.'''							)[:2]							) for layer in up_blocks[i] if '''block''' in layer}							)
        a__						={
            layer_id: [key for key in up_blocks[i] if F"""block.{layer_id}""" in key] for layer_id in range(_A							)
        }
  
        if num_blocks > 0:
          for j in range(config['''layers_per_block'''] + 1							):
            a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
            a__						=renew_resnet_paths(blocks[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   additional_replacements=[replace_indices]							)
  
      if any('''attn''' in layer for layer in up_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   2							).split('''.'''							)[:2]							) for layer in up_blocks[i] if '''attn''' in layer}							)
        a__						={
            layer_id: [key for key in up_blocks[i] if F"""attn.{layer_id}""" in key] for layer_id in range(_A							)
        }
  
        if num_attn > 0:
          for j in range(config['''layers_per_block'''] + 1							):
            a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
            a__						=renew_attention_paths(attns[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   additional_replacements=[replace_indices]							)
  
    a__						={k.replace('''mid_new_2'''			,   '''mid_block'''							): v for k, v in new_checkpoint.items()}
    return new_checkpoint
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Union[str, Any]			,   _A   :				List[Any]							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    a__						={}
  
    a__						=checkpoint['''encoder.norm_out.weight''']
    a__						=checkpoint['''encoder.norm_out.bias''']
  
    a__						=checkpoint['''encoder.conv_in.weight''']
    a__						=checkpoint['''encoder.conv_in.bias''']
    a__						=checkpoint['''encoder.conv_out.weight''']
    a__						=checkpoint['''encoder.conv_out.bias''']
  
    a__						=checkpoint['''decoder.norm_out.weight''']
    a__						=checkpoint['''decoder.norm_out.bias''']
  
    a__						=checkpoint['''decoder.conv_in.weight''']
    a__						=checkpoint['''decoder.conv_in.bias''']
    a__						=checkpoint['''decoder.conv_out.weight''']
    a__						=checkpoint['''decoder.conv_out.bias''']
  
    a__						=len({'''.'''.join(layer.split('''.'''							)[:3]							) for layer in checkpoint if '''down''' in layer}							)
    a__						={
        layer_id: [key for key in checkpoint if F"""down.{layer_id}""" in key] for layer_id in range(_A							)
    }
  
    a__						=len({'''.'''.join(layer.split('''.'''							)[:3]							) for layer in checkpoint if '''up''' in layer}							)
    a__						={layer_id: [key for key in checkpoint if F"""up.{layer_id}""" in key] for layer_id in range(_A							)}
  
    for i in range(_A							):
      a__						=(i - 1) // (config['''layers_per_block'''] + 1)
  
      if any('''downsample''' in layer for layer in down_blocks[i]							):
        a__						=checkpoint[
            F"""encoder.down.{i}.downsample.conv.weight"""
        ]
        a__						=checkpoint[
            F"""encoder.down.{i}.downsample.conv.bias"""
        ]
  
      if any('''block''' in layer for layer in down_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   3							).split('''.'''							)[:3]							) for layer in down_blocks[i] if '''block''' in layer}							)
        a__						={
            layer_id: [key for key in down_blocks[i] if F"""block.{layer_id}""" in key]
            for layer_id in range(_A							)
        }
  
        if num_blocks > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_resnet_paths(blocks[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A							)
  
      if any('''attn''' in layer for layer in down_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   3							).split('''.'''							)[:3]							) for layer in down_blocks[i] if '''attn''' in layer}							)
        a__						={
            layer_id: [key for key in down_blocks[i] if F"""attn.{layer_id}""" in key]
            for layer_id in range(_A							)
        }
  
        if num_attn > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_attention_paths(attns[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   config=_A							)
  
    a__						=[key for key in checkpoint if '''mid.block_1''' in key]
    a__						=[key for key in checkpoint if '''mid.block_2''' in key]
    a__						=[key for key in checkpoint if '''mid.attn_1''' in key]
  
    # Mid new 2
    a__						=renew_resnet_paths(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]			,   )
  
    a__						=renew_resnet_paths(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]			,   )
  
    a__						=renew_attention_paths(_A			,   in_mid=_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''attn_1''', '''new''': '''attentions.0'''}]			,   )
  
    for i in range(_A							):
      a__						=num_up_blocks - 1 - i
  
      if any('''upsample''' in layer for layer in up_blocks[i]							):
        a__						=checkpoint[
            F"""decoder.up.{i}.upsample.conv.weight"""
        ]
        a__						=checkpoint[
            F"""decoder.up.{i}.upsample.conv.bias"""
        ]
  
      if any('''block''' in layer for layer in up_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   3							).split('''.'''							)[:3]							) for layer in up_blocks[i] if '''block''' in layer}							)
        a__						={
            layer_id: [key for key in up_blocks[i] if F"""block.{layer_id}""" in key] for layer_id in range(_A							)
        }
  
        if num_blocks > 0:
          for j in range(config['''layers_per_block'''] + 1							):
            a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
            a__						=renew_resnet_paths(blocks[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   additional_replacements=[replace_indices]							)
  
      if any('''attn''' in layer for layer in up_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   3							).split('''.'''							)[:3]							) for layer in up_blocks[i] if '''attn''' in layer}							)
        a__						={
            layer_id: [key for key in up_blocks[i] if F"""attn.{layer_id}""" in key] for layer_id in range(_A							)
        }
  
        if num_attn > 0:
          for j in range(config['''layers_per_block'''] + 1							):
            a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
            a__						=renew_attention_paths(attns[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   additional_replacements=[replace_indices]							)
  
    a__						={k.replace('''mid_new_2'''			,   '''mid_block'''							): v for k, v in new_checkpoint.items()}
    a__						=checkpoint['''quant_conv.weight''']
    a__						=checkpoint['''quant_conv.bias''']
    if "quantize.embedding.weight" in checkpoint:
      a__						=checkpoint['''quantize.embedding.weight''']
    a__						=checkpoint['''post_quant_conv.weight''']
    a__						=checkpoint['''post_quant_conv.bias''']
  
    return new_checkpoint
  
  
  if __name__ == "__main__":
         lowerCamelCase     =      argparse.ArgumentParser()
  
         parser.add_argument(
             '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
         )
  
         parser.add_argument(
             '''--config_file''',
             default=None,
             type=str,
             required=True,
             help='''The config json file corresponding to the architecture.''',
         )
  
         parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
  
         lowerCamelCase     =      parser.parse_args()
         lowerCamelCase     =      torch.load(args.checkpoint_path)
  
         with open(args.config_file) as f:
                lowerCamelCase     =      json.loads(f.read())
  
         # unet case
         lowerCamelCase     =      {key.split('''.''')[0] for key in checkpoint.keys()}
         if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
                lowerCamelCase     =      convert_vq_autoenc_checkpoint(checkpoint, config)
         else:
                lowerCamelCase     =      convert_ddpm_checkpoint(checkpoint, config)
  
         if "ddpm" in config:
                del config["ddpm"]
  
         if config["_class_name"] == "VQModel":
                lowerCamelCase     =      VQModel(**config)
                model.load_state_dict(converted_checkpoint)
                model.save_pretrained(args.dump_path)
         elif config["_class_name"] == "AutoencoderKL":
                lowerCamelCase     =      AutoencoderKL(**config)
                model.load_state_dict(converted_checkpoint)
                model.save_pretrained(args.dump_path)
         else:
                lowerCamelCase     =      UNetaDModel(**config)
                model.load_state_dict(converted_checkpoint)
  
                lowerCamelCase     =      DDPMScheduler.from_config('''/'''.join(args.checkpoint_path.split('''/''')[:-1]))
  
                lowerCamelCase     =      DDPMPipeline(unet=model, scheduler=scheduler)
                pipe.save_pretrained(args.dump_path)
  
style_context: 
  
  import math
  from decimal import Decimal, getcontext
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				int = 4_00_00_00							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    try:
      a__						=int(_A							)
    except (TypeError, ValueError):
      raise TypeError('''Parameter n must be int or castable to int.'''							)
    if n <= 0:
      raise ValueError('''Parameter n must be greater than or equal to one.'''							)
    a__						=1_00
    a__						=(Decimal(5							) ** Decimal(0.5							) + 1) / Decimal(2							)
  
    a__						=(math.floor(math.log(n * (phi + 2)			,   _A							) - 1							) // 3) * 3 + 2
    a__						=Decimal(round(phi ** Decimal(index + 1							)							)							) / (phi + 2)
    a__						=num // 2
    return int(_A							)
  
  
  if __name__ == "__main__":
         print(f"""{solution() = }""")
  