



import argparse
import json
import os

import torch
from transformers.file_utils import has_file

from diffusers import UNetaDConditionModel, UNetaDModel


A_		:     Dict        =     False
A_		:     List[str]        =     True
A_		:     Dict        =     False


if __name__ == "__main__":
     A_		:     Optional[Any]        =     argparse.ArgumentParser()

     parser.add_argument(
         '''--repo_path''',
         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.''')

     A_		:     List[Any]        =     parser.parse_args()

     A_		:     Any        =     {
         '''image_size''': '''sample_size''',
         '''num_res_blocks''': '''layers_per_block''',
         '''block_channels''': '''block_out_channels''',
         '''down_blocks''': '''down_block_types''',
         '''up_blocks''': '''up_block_types''',
         '''downscale_freq_shift''': '''freq_shift''',
         '''resnet_num_groups''': '''norm_num_groups''',
         '''resnet_act_fn''': '''act_fn''',
         '''resnet_eps''': '''norm_eps''',
         '''num_head_channels''': '''attention_head_dim''',
     }

     A_		:     Any        =     {
         '''time_steps''': '''time_proj''',
         '''mid''': '''mid_block''',
         '''downsample_blocks''': '''down_blocks''',
         '''upsample_blocks''': '''up_blocks''',
     }

     A_		:     Optional[int]        =     '''''' if has_file(args.repo_path, '''config.json''') else '''unet'''

     with open(os.path.join(args.repo_path, subfolder, '''config.json'''), '''r''', encoding='''utf-8''') as reader:
          A_		:     Union[str, Any]        =     reader.read()
          A_		:     Optional[int]        =     json.loads(text)

     if do_only_config:
          for key in config_parameters_to_change.keys():
               config.pop(key, None)

     if has_file(args.repo_path, '''config.json'''):
          A_		:     Optional[int]        =     UNetaDModel(**config)
     else:
          A_		:     List[Any]        =     UNetaDConditionModel if '''ldm-text2im-large-256''' in args.repo_path else UNetaDModel
          A_		:     str        =     class_name(**config)

     if do_only_config:
          model.save_config(os.path.join(args.repo_path, subfolder))

     A_		:     Dict        =     dict(model.config)

     if do_only_renaming:
          for key, value in config_parameters_to_change.items():
               if key in config:
                    A_		:     Optional[int]        =     config[key]
                    del config[key]

          A_		:     Dict        =     [k.replace('''UNetRes''', '''''') for k in config['''down_block_types''']]
          A_		:     Optional[int]        =     [k.replace('''UNetRes''', '''''') for k in config['''up_block_types''']]

     if do_only_weights:
          A_		:     Tuple        =     torch.load(os.path.join(args.repo_path, subfolder, '''diffusion_pytorch_model.bin'''))

          A_		:     Tuple        =     {}
          for param_key, param_value in state_dict.items():
               if param_key.endswith('''.op.bias''') or param_key.endswith('''.op.weight'''):
                    continue
               A_		:     str        =     False
               for key, new_key in key_parameters_to_change.items():
                    if not has_changed and param_key.split('''.''')[0] == key:
                         A_		:     Tuple        =     param_value
                         A_		:     str        =     True
               if not has_changed:
                    A_		:     str        =     param_value

          model.load_state_dict(new_state_dict)
          model.save_pretrained(os.path.join(args.repo_path, subfolder))






A_		:     Any        =     [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
A_		:     Tuple        =     [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
A_		:     Optional[int]        =     {
    0: '''Sunday''',
    1: '''Monday''',
    2: '''Tuesday''',
    3: '''Wednesday''',
    4: '''Thursday''',
    5: '''Friday''',
    6: '''Saturday''',
}


def 	UpperCAmelCase__      (      UpperCAmelCase__ :int ,					UpperCAmelCase__ :int ,					UpperCAmelCase__ :int					):






 '''simple docstring'''

 assert len(str(UpperCAmelCase__					)					) > 2, "year should be in YYYY format"
 assert 1 <= month <= 12, "month should be between 1 to 12"
 assert 1 <= day <= 31, "day should be between 1 to 31"

 # Doomsday algorithm:
 a						=		year // 1_00
 a						=		(5 * (century % 4) + 2) % 7
 a						=		year % 1_00
 a						=		centurian % 12
 a						=		(
     (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
 ) % 7
 a						=		(
     DOOMSDAY_NOT_LEAP[month - 1]
     if (year % 4 != 0) or (centurian == 0 and (year % 4_00) == 0)
     else DOOMSDAY_LEAP[month - 1]
 )
 a						=		(dooms_day + day - day_anchor) % 7
 return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
     import doctest

     doctest.testmod()

