



"""simple docstring"""





import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class 				lowercase__       (   SCREAMING_SNAKE_CASE    , unittest.TestCase				):







       '''simple docstring'''


       UpperCamelCase						=					BertTokenizer
       UpperCamelCase						=					BertTokenizerFast
       UpperCamelCase						=					True
       UpperCamelCase						=					True
       UpperCamelCase						=					filter_non_english



       def 					lowercase__    (							self      :  int   )			->						Any:


             '''simple docstring'''




             super().setUp()

             UpperCAmelCase_      			=							[
                 "[UNK]",
                 "[CLS]",
                 "[SEP]",
                 "[PAD]",
                 "[MASK]",
                 "want",
                 "##want",
                 "##ed",
                 "wa",
                 "un",
                 "runn",
                 "##ing",
                 ",",
                 "low",
                 "lowest",
             ]
             UpperCAmelCase_      			=							os.path.join(self.tmpdirname		,    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]   )   )



       def 					lowercase__    (							self      :  int		,    _UpperCAmelCase      :  List[Any]   )			->						List[str]:


             '''simple docstring'''




             UpperCAmelCase_      			=							"UNwant\u00E9d,running"
             UpperCAmelCase_      			=							"unwanted, running"
             return input_text, output_text



       def 					lowercase__    (							self      :  int   )			->						Optional[int]:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.tokenizer_class(self.vocab_file   )

             UpperCAmelCase_      			=							tokenizer.tokenize("UNwant\u00E9d,running"   )
             self.assertListEqual(_UpperCAmelCase		,    ["un", "##want", "##ed", ",", "runn", "##ing"]   )
             self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase   )		,    [9, 6, 7, 12, 10, 11]   )



       def 					lowercase__    (							self      :  Union[str, Any]   )			->						Any:


             '''simple docstring'''




             if not self.test_rust_tokenizer:
                   return

             UpperCAmelCase_      			=							self.get_tokenizer()
             UpperCAmelCase_      			=							self.get_rust_tokenizer()

             UpperCAmelCase_      			=							"UNwant\u00E9d,running"

             UpperCAmelCase_      			=							tokenizer.tokenize(_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.tokenize(_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             UpperCAmelCase_      			=							tokenizer.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             UpperCAmelCase_      			=							self.get_rust_tokenizer()
             UpperCAmelCase_      			=							tokenizer.encode(_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.encode(_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             # With lower casing
             UpperCAmelCase_      			=							self.get_tokenizer(do_lower_case=_UpperCAmelCase   )
             UpperCAmelCase_      			=							self.get_rust_tokenizer(do_lower_case=_UpperCAmelCase   )

             UpperCAmelCase_      			=							"UNwant\u00E9d,running"

             UpperCAmelCase_      			=							tokenizer.tokenize(_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.tokenize(_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             UpperCAmelCase_      			=							tokenizer.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             UpperCAmelCase_      			=							self.get_rust_tokenizer()
             UpperCAmelCase_      			=							tokenizer.encode(_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.encode(_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )



       def 					lowercase__    (							self      :  List[Any]   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer()

             self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"   )		,    ["ah", "\u535A", "\u63A8", "zz"]   )



       def 					lowercase__    (							self      :  Optional[Any]   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "   )		,    ["hello", "!", "how", "are", "you", "?"]   )
             self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )		,    ["hello"]   )



       def 					lowercase__    (							self      :  Tuple   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase		,    strip_accents=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )		,    ["hällo", "!", "how", "are", "you", "?"]   )
             self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )		,    ["h\u00E9llo"]   )



       def 					lowercase__    (							self      :  List[Any]   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase		,    strip_accents=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )		,    ["hallo", "!", "how", "are", "you", "?"]   )
             self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )		,    ["hello"]   )



       def 					lowercase__    (							self      :  int   )			->						int:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )		,    ["hallo", "!", "how", "are", "you", "?"]   )
             self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )		,    ["hello"]   )



       def 					lowercase__    (							self      :  Dict   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "   )		,    ["HeLLo", "!", "how", "Are", "yoU", "?"]   )



       def 					lowercase__    (							self      :  Union[str, Any]   )			->						Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase		,    strip_accents=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )		,    ["HäLLo", "!", "how", "Are", "yoU", "?"]   )



       def 					lowercase__    (							self      :  int   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase		,    strip_accents=_UpperCAmelCase   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )		,    ["HaLLo", "!", "how", "Are", "yoU", "?"]   )



       def 					lowercase__    (							self      :  Optional[Any]   )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer(do_lower_case=_UpperCAmelCase		,    never_split=["[UNK]"]   )

             self.assertListEqual(
                 tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"   )		,    ["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]   )



       def 					lowercase__    (							self      :  Any   )			->						Any:


             '''simple docstring'''




             UpperCAmelCase_      			=							BasicTokenizer()
             UpperCAmelCase_      			=							"a\n'll !!to?'d of, can't."
             UpperCAmelCase_      			=							["a", "'", "ll", "!", "!", "to", "?", "'", "d", "of", ",", "can", "'", "t", "."]
             self.assertListEqual(tokenizer.tokenize(_UpperCAmelCase   )		,    _UpperCAmelCase   )



       def 					lowercase__    (							self      :  Optional[int]   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

             UpperCAmelCase_      			=							{}
             for i, token in enumerate(_UpperCAmelCase   ):
                   UpperCAmelCase_      			=							i
             UpperCAmelCase_      			=							WordpieceTokenizer(vocab=_UpperCAmelCase		,    unk_token="[UNK]"   )

             self.assertListEqual(tokenizer.tokenize(""   )		,    []   )

             self.assertListEqual(tokenizer.tokenize("unwanted running"   )		,    ["un", "##want", "##ed", "runn", "##ing"]   )

             self.assertListEqual(tokenizer.tokenize("unwantedX running"   )		,    ["[UNK]", "runn", "##ing"]   )



       def 					lowercase__    (							self      :  Tuple   )			->						List[str]:


             '''simple docstring'''




             self.assertTrue(_is_whitespace(" "   )   )
             self.assertTrue(_is_whitespace("\t"   )   )
             self.assertTrue(_is_whitespace("\r"   )   )
             self.assertTrue(_is_whitespace("\n"   )   )
             self.assertTrue(_is_whitespace("\u00A0"   )   )

             self.assertFalse(_is_whitespace("A"   )   )
             self.assertFalse(_is_whitespace("-"   )   )



       def 					lowercase__    (							self      :  Optional[Any]   )			->						Union[str, Any]:


             '''simple docstring'''




             self.assertTrue(_is_control("\u0005"   )   )

             self.assertFalse(_is_control("A"   )   )
             self.assertFalse(_is_control(" "   )   )
             self.assertFalse(_is_control("\t"   )   )
             self.assertFalse(_is_control("\r"   )   )



       def 					lowercase__    (							self      :  Optional[Any]   )			->						List[str]:


             '''simple docstring'''




             self.assertTrue(_is_punctuation("-"   )   )
             self.assertTrue(_is_punctuation("$"   )   )
             self.assertTrue(_is_punctuation("`"   )   )
             self.assertTrue(_is_punctuation("."   )   )

             self.assertFalse(_is_punctuation("A"   )   )
             self.assertFalse(_is_punctuation(" "   )   )



       def 					lowercase__    (							self      :  int   )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.get_tokenizer()
             UpperCAmelCase_      			=							self.get_rust_tokenizer()

             # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
             self.assertListEqual([tokenizer.tokenize(_UpperCAmelCase   ) for t in ["Test", "\xad", "test"]]		,    [["[UNK]"], [], ["[UNK]"]]   )

             self.assertListEqual(
                 [rust_tokenizer.tokenize(_UpperCAmelCase   ) for t in ["Test", "\xad", "test"]]		,    [["[UNK]"], [], ["[UNK]"]]   )



       @slow
       def 					lowercase__    (							self      :  Any   )			->						List[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.tokenizer_class.from_pretrained("bert-base-uncased"   )

             UpperCAmelCase_      			=							tokenizer.encode("sequence builders"		,    add_special_tokens=_UpperCAmelCase   )
             UpperCAmelCase_      			=							tokenizer.encode("multi-sequence build"		,    add_special_tokens=_UpperCAmelCase   )

             UpperCAmelCase_      			=							tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase   )
             UpperCAmelCase_      			=							tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase		,    _UpperCAmelCase   )

             assert encoded_sentence == [101] + text + [102]
             assert encoded_pair == [101] + text + [102] + text_a + [102]



       def 					lowercase__    (							self      :  Optional[int]   )			->						str:


             '''simple docstring'''




             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                   with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
                         UpperCAmelCase_      			=							self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase		,    **_UpperCAmelCase   )

                         UpperCAmelCase_      			=							F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
                         UpperCAmelCase_      			=							tokenizer_r.encode_plus(
                             _UpperCAmelCase		,    return_attention_mask=_UpperCAmelCase		,    return_token_type_ids=_UpperCAmelCase		,    return_offsets_mapping=_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase		,    )

                         UpperCAmelCase_      			=							tokenizer_r.do_lower_case if hasattr(_UpperCAmelCase		,    "do_lower_case"   ) else False
                         UpperCAmelCase_      			=							(
                             [
                                 ((0, 0), tokenizer_r.cls_token),
                                 ((0, 1), "A"),
                                 ((1, 2), ","),
                                 ((3, 5), "na"),
                                 ((5, 6), "##ï"),
                                 ((6, 8), "##ve"),
                                 ((9, 15), tokenizer_r.mask_token),
                                 ((16, 21), "Allen"),
                                 ((21, 23), "##NL"),
                                 ((23, 24), "##P"),
                                 ((25, 33), "sentence"),
                                 ((33, 34), "."),
                                 ((0, 0), tokenizer_r.sep_token),
                             ]
                             if not do_lower_case
                             else [
                                 ((0, 0), tokenizer_r.cls_token),
                                 ((0, 1), "a"),
                                 ((1, 2), ","),
                                 ((3, 8), "naive"),
                                 ((9, 15), tokenizer_r.mask_token),
                                 ((16, 21), "allen"),
                                 ((21, 23), "##nl"),
                                 ((23, 24), "##p"),
                                 ((25, 33), "sentence"),
                                 ((33, 34), "."),
                                 ((0, 0), tokenizer_r.sep_token),
                             ]
                         )

                         self.assertEqual(
                             [e[1] for e in expected_results]		,    tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]   )   )
                         self.assertEqual([e[0] for e in expected_results]		,    tokens["offset_mapping"]   )







       def 					lowercase__    (							self      :  Union[str, Any]   )			->						Any:


             '''simple docstring'''




             UpperCAmelCase_      			=							["的", "人", "有"]
             UpperCAmelCase_      			=							"".join(_UpperCAmelCase   )
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                   with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
                         UpperCAmelCase_      			=							True
                         UpperCAmelCase_      			=							self.tokenizer_class.from_pretrained(_UpperCAmelCase		,    **_UpperCAmelCase   )
                         UpperCAmelCase_      			=							self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase		,    **_UpperCAmelCase   )

                         UpperCAmelCase_      			=							tokenizer_p.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
                         UpperCAmelCase_      			=							tokenizer_r.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )

                         UpperCAmelCase_      			=							tokenizer_r.convert_ids_to_tokens(_UpperCAmelCase   )
                         UpperCAmelCase_      			=							tokenizer_p.convert_ids_to_tokens(_UpperCAmelCase   )

                         # it is expected that each Chinese character is not preceded by "##"
                         self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )
                         self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

                         UpperCAmelCase_      			=							False
                         UpperCAmelCase_      			=							self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase		,    **_UpperCAmelCase   )
                         UpperCAmelCase_      			=							self.tokenizer_class.from_pretrained(_UpperCAmelCase		,    **_UpperCAmelCase   )

                         UpperCAmelCase_      			=							tokenizer_r.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
                         UpperCAmelCase_      			=							tokenizer_p.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )

                         UpperCAmelCase_      			=							tokenizer_r.convert_ids_to_tokens(_UpperCAmelCase   )
                         UpperCAmelCase_      			=							tokenizer_p.convert_ids_to_tokens(_UpperCAmelCase   )

                         # it is expected that only the first Chinese character is not preceded by "##".
                         UpperCAmelCase_      			=							[
                             F"""##{token}""" if idx != 0 else token for idx, token in enumerate(_UpperCAmelCase   )
                         ]
                         self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )
                         self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )









"""simple docstring"""





import argparse
import io

import requests
import torch
from omegaconf import OmegaConf

from diffusers import AutoencoderKL
from diffusers.pipelines.stable_diffusion.convert_from_ckpt import (
    assign_to_checkpoint,
    conv_attn_to_linear,
    create_vae_diffusers_config,
    renew_vae_attention_paths,
    renew_vae_resnet_paths,
)
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      UpperCAmelCase_      			=							checkpoint

      UpperCAmelCase_      			=							{}

      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_in.weight"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_in.bias"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_out.bias"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.norm_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.norm_out.bias"]

      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_in.weight"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_in.bias"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_out.bias"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.norm_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.norm_out.bias"]

      UpperCAmelCase_      			=							vae_state_dict["quant_conv.weight"]
      UpperCAmelCase_      			=							vae_state_dict["quant_conv.bias"]
      UpperCAmelCase_      			=							vae_state_dict["post_quant_conv.weight"]
      UpperCAmelCase_      			=							vae_state_dict["post_quant_conv.bias"]

      # Retrieves the keys for the encoder down blocks only
      UpperCAmelCase_      			=							len({".".join(layer.split("."				)[:3]				) for layer in vae_state_dict if "encoder.down" in layer}				)
      UpperCAmelCase_      			=							{
          layer_id: [key for key in vae_state_dict if f"""down.{layer_id}""" in key] for layer_id in range(lowerCAmelCase__				)
      }

      # Retrieves the keys for the decoder up blocks only
      UpperCAmelCase_      			=							len({".".join(layer.split("."				)[:3]				) for layer in vae_state_dict if "decoder.up" in layer}				)
      UpperCAmelCase_      			=							{
          layer_id: [key for key in vae_state_dict if f"""up.{layer_id}""" in key] for layer_id in range(lowerCAmelCase__				)
      }

      for i in range(lowerCAmelCase__				):
            UpperCAmelCase_      			=							[key for key in down_blocks[i] if f"""down.{i}""" in key and f"""down.{i}.downsample""" not in key]

            if f"""encoder.down.{i}.downsample.conv.weight""" in vae_state_dict:
                  UpperCAmelCase_      			=							vae_state_dict.pop(
                      f"""encoder.down.{i}.downsample.conv.weight"""				)
                  UpperCAmelCase_      			=							vae_state_dict.pop(
                      f"""encoder.down.{i}.downsample.conv.bias"""				)

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""down.{i}.block""", "new": f"""down_blocks.{i}.resnets"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "encoder.mid.block" in key]
      UpperCAmelCase_      			=							2
      for i in range(1     ,      num_mid_res_blocks + 1				):
            UpperCAmelCase_      			=							[key for key in mid_resnets if f"""encoder.mid.block_{i}""" in key]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""mid.block_{i}""", "new": f"""mid_block.resnets.{i - 1}"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "encoder.mid.attn" in key]
      UpperCAmelCase_      			=							renew_vae_attention_paths(lowerCAmelCase__				)
      UpperCAmelCase_      			=							{"old": "mid.attn_1", "new": "mid_block.attentions.0"}
      assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)
      conv_attn_to_linear(lowerCAmelCase__				)

      for i in range(lowerCAmelCase__				):
            UpperCAmelCase_      			=							num_up_blocks - 1 - i
            UpperCAmelCase_      			=							[
                key for key in up_blocks[block_id] if f"""up.{block_id}""" in key and f"""up.{block_id}.upsample""" not in key
            ]

            if f"""decoder.up.{block_id}.upsample.conv.weight""" in vae_state_dict:
                  UpperCAmelCase_      			=							vae_state_dict[
                      f"""decoder.up.{block_id}.upsample.conv.weight"""
                  ]
                  UpperCAmelCase_      			=							vae_state_dict[
                      f"""decoder.up.{block_id}.upsample.conv.bias"""
                  ]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""up.{block_id}.block""", "new": f"""up_blocks.{i}.resnets"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "decoder.mid.block" in key]
      UpperCAmelCase_      			=							2
      for i in range(1     ,      num_mid_res_blocks + 1				):
            UpperCAmelCase_      			=							[key for key in mid_resnets if f"""decoder.mid.block_{i}""" in key]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""mid.block_{i}""", "new": f"""mid_block.resnets.{i - 1}"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "decoder.mid.attn" in key]
      UpperCAmelCase_      			=							renew_vae_attention_paths(lowerCAmelCase__				)
      UpperCAmelCase_      			=							{"old": "mid.attn_1", "new": "mid_block.attentions.0"}
      assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)
      conv_attn_to_linear(lowerCAmelCase__				)
      return new_checkpoint
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__     ,      ):
      # Only support V1
      UpperCAmelCase_      			=							requests.get(
          " https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml"				)
      UpperCAmelCase_      			=							io.BytesIO(r.content				)

      UpperCAmelCase_      			=							OmegaConf.load(lowerCAmelCase__				)
      UpperCAmelCase_      			=							512
      UpperCAmelCase_      			=							"cuda" if torch.cuda.is_available() else "cpu"
      if checkpoint_path.endswith("safetensors"				):
            from safetensors import safe_open

            UpperCAmelCase_      			=							{}
            with safe_open(lowerCAmelCase__     ,      framework="pt"     ,      device="cpu"				) as f:
                  for key in f.keys():
                        UpperCAmelCase_      			=							f.get_tensor(lowerCAmelCase__				)
      else:
            UpperCAmelCase_      			=							torch.load(lowerCAmelCase__     ,      map_location=lowerCAmelCase__				)["state_dict"]

      # Convert the VAE model.
      UpperCAmelCase_      			=							create_vae_diffusers_config(lowerCAmelCase__     ,      image_size=lowerCAmelCase__				)
      UpperCAmelCase_      			=							custom_convert_ldm_vae_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__				)

      UpperCAmelCase_      			=							AutoencoderKL(**lowerCAmelCase__				)
      vae.load_state_dict(lowerCAmelCase__				)
      vae.save_pretrained(lowerCAmelCase__				)


if __name__ == "__main__":
  lowerCamelCase       	=						argparse.ArgumentParser()

  parser.add_argument("""--vae_pt_path""", default=None, type=str, required=True, help="""Path to the VAE.pt to convert.""")
  parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the VAE.pt to convert.""")

  lowerCamelCase       	=						parser.parse_args()

  vae_pt_to_vae_diffuser(args.vae_pt_path, args.dump_path)




