
import argparse
import json
import pickle
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowercase  : List[str]						   =							logging.get_logger(__name__)







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   Tuple:
       lowercase							:					Tuple	     =				SwinConfig.from_pretrained(
           """microsoft/swin-tiny-patch4-window7-224""" ,     out_features=["""stage1""", """stage2""", """stage3""", """stage4"""]    )
       lowercase							:					str	     =				MaskFormerConfig(backbone_config=SCREAMING_SNAKE_CASE__    )

       lowercase							:					Dict	     =				"""huggingface/label-files"""
       if "ade20k-full" in model_name:
              # this should be ok
              lowercase							:					List[Any]	     =				847
              lowercase							:					List[Any]	     =				"""maskformer-ade20k-full-id2label.json"""
       elif "ade" in model_name:
              # this should be ok
              lowercase							:					Optional[Any]	     =				150
              lowercase							:					int	     =				"""ade20k-id2label.json"""
       elif "coco-stuff" in model_name:
              # this should be ok
              lowercase							:					int	     =				171
              lowercase							:					Tuple	     =				"""maskformer-coco-stuff-id2label.json"""
       elif "coco" in model_name:
              # TODO
              lowercase							:					Optional[int]	     =				133
              lowercase							:					List[Any]	     =				"""coco-panoptic-id2label.json"""
       elif "cityscapes" in model_name:
              # this should be ok
              lowercase							:					int	     =				19
              lowercase							:					str	     =				"""cityscapes-id2label.json"""
       elif "vistas" in model_name:
              # this should be ok
              lowercase							:					Optional[Any]	     =				65
              lowercase							:					Tuple	     =				"""mapillary-vistas-id2label.json"""

       lowercase							:					str	     =				json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     repo_type="""dataset"""    ) ,     """r"""    )    )
       lowercase							:					Any	     =				{int(SCREAMING_SNAKE_CASE__    ): v for k, v in idalabel.items()}

       return config







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   Optional[Any]:
       lowercase							:					Tuple	     =				[]
       # stem
       # fmt: off
       rename_keys.append(("""backbone.patch_embed.proj.weight""", """model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight""")    )
       rename_keys.append(("""backbone.patch_embed.proj.bias""", """model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias""")    )
       rename_keys.append(("""backbone.patch_embed.norm.weight""", """model.pixel_level_module.encoder.model.embeddings.norm.weight""")    )
       rename_keys.append(("""backbone.patch_embed.norm.bias""", """model.pixel_level_module.encoder.model.embeddings.norm.bias""")    )
       # stages
       for i in range(len(config.backbone_config.depths    )    ):
              for j in range(config.backbone_config.depths[i]    ):
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm1.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm1.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.relative_position_index", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.proj.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.attn.proj.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm2.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.norm2.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc1.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc1.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc2.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.blocks.{j}.mlp.fc2.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias")    )

              if i < 3:
                     rename_keys.append((f"backbone.layers.{i}.downsample.reduction.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.downsample.norm.weight", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight")    )
                     rename_keys.append((f"backbone.layers.{i}.downsample.norm.bias", f"model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias")    )
              rename_keys.append((f"backbone.norm{i}.weight", f"model.pixel_level_module.encoder.hidden_states_norms.{i}.weight")    )
              rename_keys.append((f"backbone.norm{i}.bias", f"model.pixel_level_module.encoder.hidden_states_norms.{i}.bias")    )

       # FPN
       rename_keys.append(("""sem_seg_head.layer_4.weight""", """model.pixel_level_module.decoder.fpn.stem.0.weight""")    )
       rename_keys.append(("""sem_seg_head.layer_4.norm.weight""", """model.pixel_level_module.decoder.fpn.stem.1.weight""")    )
       rename_keys.append(("""sem_seg_head.layer_4.norm.bias""", """model.pixel_level_module.decoder.fpn.stem.1.bias""")    )
       for source_index, target_index in zip(range(3 ,     0 ,     -1    ) ,     range(0 ,     3    )    ):
              rename_keys.append((f"sem_seg_head.adapter_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight")    )
              rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight")    )
              rename_keys.append((f"sem_seg_head.adapter_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias")    )
              rename_keys.append((f"sem_seg_head.layer_{source_index}.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight")    )
              rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.weight", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight")    )
              rename_keys.append((f"sem_seg_head.layer_{source_index}.norm.bias", f"model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias")    )
       rename_keys.append(("""sem_seg_head.mask_features.weight""", """model.pixel_level_module.decoder.mask_projection.weight""")    )
       rename_keys.append(("""sem_seg_head.mask_features.bias""", """model.pixel_level_module.decoder.mask_projection.bias""")    )

       # Transformer decoder
       for idx in range(config.decoder_config.decoder_layers    ):
              # self-attention out projection
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias")    )
              # cross-attention out projection
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias")    )
              # MLP 1
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight", f"model.transformer_module.decoder.layers.{idx}.fc1.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias", f"model.transformer_module.decoder.layers.{idx}.fc1.bias")    )
              # MLP 2
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight", f"model.transformer_module.decoder.layers.{idx}.fc2.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias", f"model.transformer_module.decoder.layers.{idx}.fc2.bias")    )
              # layernorm 1 (self-attention layernorm)
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias", f"model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias")    )
              # layernorm 2 (cross-attention layernorm)
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias", f"model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias")    )
              # layernorm 3 (final layernorm)
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias", f"model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias")    )

       rename_keys.append(("""sem_seg_head.predictor.transformer.decoder.norm.weight""", """model.transformer_module.decoder.layernorm.weight""")    )
       rename_keys.append(("""sem_seg_head.predictor.transformer.decoder.norm.bias""", """model.transformer_module.decoder.layernorm.bias""")    )

       # heads on top
       rename_keys.append(("""sem_seg_head.predictor.query_embed.weight""", """model.transformer_module.queries_embedder.weight""")    )

       rename_keys.append(("""sem_seg_head.predictor.input_proj.weight""", """model.transformer_module.input_projection.weight""")    )
       rename_keys.append(("""sem_seg_head.predictor.input_proj.bias""", """model.transformer_module.input_projection.bias""")    )

       rename_keys.append(("""sem_seg_head.predictor.class_embed.weight""", """class_predictor.weight""")    )
       rename_keys.append(("""sem_seg_head.predictor.class_embed.bias""", """class_predictor.bias""")    )

       for i in range(3    ):
              rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.weight", f"mask_embedder.{i}.0.weight")    )
              rename_keys.append((f"sem_seg_head.predictor.mask_embed.layers.{i}.bias", f"mask_embedder.{i}.0.bias")    )
       # fmt: on

       return rename_keys







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Optional[int]:
       lowercase							:					List[Any]	     =				dct.pop(SCREAMING_SNAKE_CASE__    )
       lowercase							:					str	     =				val







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Dict:
       lowercase							:					List[str]	     =				[int(backbone_config.embed_dim * 2**i    ) for i in range(len(backbone_config.depths    )    )]
       for i in range(len(backbone_config.depths    )    ):
              lowercase							:					str	     =				num_features[i]
              for j in range(backbone_config.depths[i]    ):
                     # fmt: off
                     # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
                     lowercase							:					Dict	     =				state_dict.pop(f"backbone.layers.{i}.blocks.{j}.attn.qkv.weight"    )
                     lowercase							:					str	     =				state_dict.pop(f"backbone.layers.{i}.blocks.{j}.attn.qkv.bias"    )
                     # next, add query, keys and values (in that order) to the state dict
                     lowercase							:					Union[str, Any]	     =				in_proj_weight[:dim, :]
                     lowercase							:					str	     =				in_proj_bias[: dim]
                     lowercase							:					Union[str, Any]	     =				in_proj_weight[
                         dim : dim * 2, :
                     ]
                     lowercase							:					Any	     =				in_proj_bias[
                         dim : dim * 2
                     ]
                     lowercase							:					Optional[Any]	     =				in_proj_weight[
                         -dim :, :
                     ]
                     lowercase							:					Any	     =				in_proj_bias[-dim :]
                     # fmt: on







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Tuple:
       # fmt: off
       lowercase							:					Dict	     =				config.decoder_config.hidden_size
       for idx in range(config.decoder_config.decoder_layers    ):
              # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
              lowercase							:					Dict	     =				state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight"    )
              lowercase							:					Dict	     =				state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias"    )
              # next, add query, keys and values (in that order) to the state dict
              lowercase							:					str	     =				in_proj_weight[: hidden_size, :]
              lowercase							:					Union[str, Any]	     =				in_proj_bias[:config.hidden_size]
              lowercase							:					Tuple	     =				in_proj_weight[hidden_size : hidden_size * 2, :]
              lowercase							:					Dict	     =				in_proj_bias[hidden_size : hidden_size * 2]
              lowercase							:					Any	     =				in_proj_weight[-hidden_size :, :]
              lowercase							:					Optional[int]	     =				in_proj_bias[-hidden_size :]
              # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
              lowercase							:					Union[str, Any]	     =				state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight"    )
              lowercase							:					Dict	     =				state_dict.pop(f"sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias"    )
              # next, add query, keys and values (in that order) to the state dict
              lowercase							:					List[Any]	     =				in_proj_weight[: hidden_size, :]
              lowercase							:					List[str]	     =				in_proj_bias[:config.hidden_size]
              lowercase							:					str	     =				in_proj_weight[hidden_size : hidden_size * 2, :]
              lowercase							:					Dict	     =				in_proj_bias[hidden_size : hidden_size * 2]
              lowercase							:					Optional[Any]	     =				in_proj_weight[-hidden_size :, :]
              lowercase							:					Union[str, Any]	     =				in_proj_bias[-hidden_size :]
       # fmt: on







def 						_snake_case(  )			->   torch.Tensor:
       lowercase							:					Union[str, Any]	     =				"""http://images.cocodataset.org/val2017/000000039769.jpg"""
       lowercase							:					Optional[int]	     =				Image.open(requests.get(SCREAMING_SNAKE_CASE__ ,     stream=SCREAMING_SNAKE_CASE__    ).raw    )
       return im







@torch.no_grad()
def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = False    )			->   Tuple:
       lowercase							:					int	     =				get_maskformer_config(SCREAMING_SNAKE_CASE__    )

       # load original state_dict
       with open(SCREAMING_SNAKE_CASE__ ,     """rb"""    ) as f:
              lowercase							:					Any	     =				pickle.load(SCREAMING_SNAKE_CASE__    )
       lowercase							:					Optional[Any]	     =				data["""model"""]

       # for name, param in state_dict.items():
       #     print(name, param.shape)

       # rename keys
       lowercase							:					Union[str, Any]	     =				create_rename_keys(SCREAMING_SNAKE_CASE__    )
       for src, dest in rename_keys:
              rename_key(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
       read_in_swin_q_k_v(SCREAMING_SNAKE_CASE__ ,     config.backbone_config    )
       read_in_decoder_q_k_v(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )

       # update to torch tensors
       for key, value in state_dict.items():
              lowercase							:					str	     =				torch.from_numpy(SCREAMING_SNAKE_CASE__    )

       # load 🤗 model
       lowercase							:					Union[str, Any]	     =				MaskFormerForInstanceSegmentation(SCREAMING_SNAKE_CASE__    )
       model.eval()

       for name, param in model.named_parameters():
              print(SCREAMING_SNAKE_CASE__ ,     param.shape    )

       lowercase     ,      lowercase							:					Optional[int]	     =				model.load_state_dict(SCREAMING_SNAKE_CASE__ ,     strict=SCREAMING_SNAKE_CASE__    )
       assert missing_keys == [
           "model.pixel_level_module.encoder.model.layernorm.weight",
           "model.pixel_level_module.encoder.model.layernorm.bias",
       ]
       assert len(SCREAMING_SNAKE_CASE__    ) == 0, f"Unexpected keys: {unexpected_keys}"

       # verify results
       lowercase							:					str	     =				prepare_img()
       if "vistas" in model_name:
              lowercase							:					int	     =				65
       elif "cityscapes" in model_name:
              lowercase							:					Dict	     =				65_535
       else:
              lowercase							:					List[Any]	     =				255
       lowercase							:					Optional[Any]	     =				True if """ade""" in model_name else False
       lowercase							:					Any	     =				MaskFormerImageProcessor(ignore_index=SCREAMING_SNAKE_CASE__ ,     reduce_labels=SCREAMING_SNAKE_CASE__    )

       lowercase							:					Union[str, Any]	     =				image_processor(SCREAMING_SNAKE_CASE__ ,     return_tensors="""pt"""    )

       lowercase							:					List[Any]	     =				model(**SCREAMING_SNAKE_CASE__    )

       print("""Logits:""" ,     outputs.class_queries_logits[0, :3, :3]    )

       if model_name == "maskformer-swin-tiny-ade":
              lowercase							:					str	     =				torch.tensor(
                  [[3.6353, -4.4770, -2.6065], [0.5081, -4.2394, -3.5343], [2.1909, -5.0353, -1.9323]]    )
       assert torch.allclose(outputs.class_queries_logits[0, :3, :3] ,     SCREAMING_SNAKE_CASE__ ,     atol=1e-4    )
       print("""Looks ok!"""    )

       if pytorch_dump_folder_path is not None:
              print(f"Saving model and image processor to {pytorch_dump_folder_path}"    )
              Path(SCREAMING_SNAKE_CASE__    ).mkdir(exist_ok=SCREAMING_SNAKE_CASE__    )
              model.save_pretrained(SCREAMING_SNAKE_CASE__    )
              image_processor.save_pretrained(SCREAMING_SNAKE_CASE__    )

       if push_to_hub:
              print("""Pushing model and image processor to the hub..."""    )
              model.push_to_hub(f"nielsr/{model_name}"    )
              image_processor.push_to_hub(f"nielsr/{model_name}"    )


if __name__ == "__main__":
  lowercase  : Optional[int]						   =							argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--model_name""",
      default="""maskformer-swin-tiny-ade""",
      type=str,
      help=("""Name of the MaskFormer model you'd like to convert""",),
  )
  parser.add_argument(
      """--checkpoint_path""",
      default="""/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl""",
      type=str,
      help="""Path to the original state dict (.pth file).""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
  )
  parser.add_argument(
      """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
  )

  lowercase  : Dict						   =							parser.parse_args()
  convert_maskformer_checkpoint(
      args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
  )


import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


lowercase  : Tuple						   =							get_logger(__name__)


lowercase  : Optional[int]						   =							Path(__file__).parent / """model_card_template.md"""
lowercase  : Dict						   =							uuida().hex
lowercase  : Tuple						   =							os.getenv("""HF_HUB_OFFLINE""", """""").upper() in ENV_VARS_TRUE_VALUES
lowercase  : str						   =							os.getenv("""DISABLE_TELEMETRY""", """""").upper() in ENV_VARS_TRUE_VALUES
lowercase  : Tuple						   =							HUGGINGFACE_CO_RESOLVE_ENDPOINT + """/api/telemetry/"""







def 						_snake_case(  SCREAMING_SNAKE_CASE__ = None    )			->   str:
       lowercase							:					str	     =				f"diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}"
       if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
              return ua + "; telemetry/off"
       if is_torch_available():
              ua += f"; torch/{_torch_version}"
       if is_flax_available():
              ua += f"; jax/{_jax_version}"
              ua += f"; flax/{_flax_version}"
       if is_onnx_available():
              ua += f"; onnxruntime/{_onnxruntime_version}"
       # CI will set this value to True
       if os.environ.get("""DIFFUSERS_IS_CI""" ,     """"""    ).upper() in ENV_VARS_TRUE_VALUES:
              ua += "; is_ci/true"
       if isinstance(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ):
              ua += "; " + "; ".join(f"{k}/{v}" for k, v in user_agent.items()    )
       elif isinstance(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ):
              ua += "; " + user_agent
       return ua







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None ,     SCREAMING_SNAKE_CASE__ = None    )			->   Dict:
       if token is None:
              lowercase							:					Optional[int]	     =				HfFolder.get_token()
       if organization is None:
              lowercase							:					int	     =				whoami(SCREAMING_SNAKE_CASE__    )["""name"""]
              return f"{username}/{model_id}"
       else:
              return f"{organization}/{model_id}"







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Tuple:
       if not is_jinja_available():
              raise ValueError(
                  """Modelcard rendering is based on Jinja templates."""
                  """ Please make sure to have `jinja` installed before using `create_model_card`."""
                  """ To install it, please run `pip install Jinja2`."""    )

       if hasattr(SCREAMING_SNAKE_CASE__ ,     """local_rank"""    ) and args.local_rank not in [-1, 0]:
              return

       lowercase							:					str	     =				args.hub_token if hasattr(SCREAMING_SNAKE_CASE__ ,     """hub_token"""    ) else None
       lowercase							:					int	     =				get_full_repo_name(SCREAMING_SNAKE_CASE__ ,     token=SCREAMING_SNAKE_CASE__    )

       lowercase							:					Dict	     =				ModelCard.from_template(
           card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
               language="""en""" ,     license="""apache-2.0""" ,     library_name="""diffusers""" ,     tags=[] ,     datasets=args.dataset_name ,     metrics=[] ,     ) ,     template_path=SCREAMING_SNAKE_CASE__ ,     model_name=SCREAMING_SNAKE_CASE__ ,     repo_name=SCREAMING_SNAKE_CASE__ ,     dataset_name=args.dataset_name if hasattr(SCREAMING_SNAKE_CASE__ ,     """dataset_name"""    ) else None ,     learning_rate=args.learning_rate ,     train_batch_size=args.train_batch_size ,     eval_batch_size=args.eval_batch_size ,     gradient_accumulation_steps=(
               args.gradient_accumulation_steps if hasattr(SCREAMING_SNAKE_CASE__ ,     """gradient_accumulation_steps"""    ) else None
           ) ,     adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_beta1"""    ) else None ,     adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_beta2"""    ) else None ,     adam_weight_decay=args.adam_weight_decay if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_weight_decay"""    ) else None ,     adam_epsilon=args.adam_epsilon if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_epsilon"""    ) else None ,     lr_scheduler=args.lr_scheduler if hasattr(SCREAMING_SNAKE_CASE__ ,     """lr_scheduler"""    ) else None ,     lr_warmup_steps=args.lr_warmup_steps if hasattr(SCREAMING_SNAKE_CASE__ ,     """lr_warmup_steps"""    ) else None ,     ema_inv_gamma=args.ema_inv_gamma if hasattr(SCREAMING_SNAKE_CASE__ ,     """ema_inv_gamma"""    ) else None ,     ema_power=args.ema_power if hasattr(SCREAMING_SNAKE_CASE__ ,     """ema_power"""    ) else None ,     ema_max_decay=args.ema_max_decay if hasattr(SCREAMING_SNAKE_CASE__ ,     """ema_max_decay"""    ) else None ,     mixed_precision=args.mixed_precision ,     )

       lowercase							:					str	     =				os.path.join(args.output_dir ,     """README.md"""    )
       model_card.save(SCREAMING_SNAKE_CASE__    )







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None    )			->   Optional[Any]:
       if resolved_file is None or commit_hash is not None:
              return commit_hash
       lowercase							:					List[Any]	     =				str(Path(SCREAMING_SNAKE_CASE__    ).as_posix()    )
       lowercase							:					Any	     =				re.search(R"""snapshots/([^/]+)/""" ,     SCREAMING_SNAKE_CASE__    )
       if search is None:
              return None
       lowercase							:					List[Any]	     =				search.groups()[0]
       return commit_hash if REGEX_COMMIT_HASH.match(SCREAMING_SNAKE_CASE__    ) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
lowercase  : Optional[Any]						   =							os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
lowercase  : Optional[int]						   =							os.path.join(hf_cache_home, """diffusers""")







def 						_snake_case(  SCREAMING_SNAKE_CASE__ = None ,     SCREAMING_SNAKE_CASE__ = None    )			->   None:
       if new_cache_dir is None:
              lowercase							:					Union[str, Any]	     =				DIFFUSERS_CACHE
       if old_cache_dir is None:
              lowercase							:					List[str]	     =				old_diffusers_cache

       lowercase							:					Dict	     =				Path(SCREAMING_SNAKE_CASE__    ).expanduser()
       lowercase							:					int	     =				Path(SCREAMING_SNAKE_CASE__    ).expanduser()
       for old_blob_path in old_cache_dir.glob("""**/blobs/*"""    ):
              if old_blob_path.is_file() and not old_blob_path.is_symlink():
                     lowercase							:					Any	     =				new_cache_dir / old_blob_path.relative_to(SCREAMING_SNAKE_CASE__    )
                     new_blob_path.parent.mkdir(parents=SCREAMING_SNAKE_CASE__ ,     exist_ok=SCREAMING_SNAKE_CASE__    )
                     os.replace(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     try:
                            os.symlink(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     except OSError:
                            logger.warning(
                                """Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded."""    )
       # At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


lowercase  : Dict						   =							os.path.join(DIFFUSERS_CACHE, """version_diffusers_cache.txt""")
if not os.path.isfile(cache_version_file):
  lowercase  : Any						   =							0
else:
  with open(cache_version_file) as f:
    try:
      lowercase  : List[Any]						   =							int(f.read())
    except ValueError:
      lowercase  : int						   =							0

if cache_version < 1:
  lowercase  : Union[str, Any]						   =							os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
  if old_cache_is_not_empty:
    logger.warning(
        """The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your """
        """existing cached models. This is a one-time operation, you can interrupt it or run it """
        """later by calling `diffusers.utils.hub_utils.move_cache()`."""
    )
    try:
      move_cache()
    except Exception as e:
      lowercase  : int						   =							"""\n""".join(traceback.format_tb(e.__traceback__))
      logger.error(
          F'''There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease '''
          """file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole """
          """message and we will do our best to help."""
      )

if cache_version < 1:
  try:
    os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
    with open(cache_version_file, """w""") as f:
      f.write("""1""")
  except Exception:
    logger.warning(
        F'''There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure '''
        """the directory exists and can be written to."""
    )







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None    )			->   str:
       if variant is not None:
              lowercase							:					List[str]	     =				weights_name.split("""."""    )
              lowercase							:					Optional[Any]	     =				splits[:-1] + [variant] + splits[-1:]
              lowercase							:					int	     =				""".""".join(SCREAMING_SNAKE_CASE__    )

       return weights_name







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     *,
    SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__=None ,     )			->   Optional[Any]:
       lowercase							:					Optional[int]	     =				str(SCREAMING_SNAKE_CASE__    )
       if os.path.isfile(SCREAMING_SNAKE_CASE__    ):
              return pretrained_model_name_or_path
       elif os.path.isdir(SCREAMING_SNAKE_CASE__    ):
              if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )    ):
                     # Load from a PyTorch checkpoint
                     lowercase							:					List[Any]	     =				os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     return model_file
              elif subfolder is not None and os.path.isfile(
                  os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )    ):
                     lowercase							:					Any	     =				os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     return model_file
              else:
                     raise EnvironmentError(
                         f"Error no file named {weights_name} found in directory {pretrained_model_name_or_path}."    )
       else:
              # 1. First check if deprecated way of loading from branches is used
              if (
                  revision in DEPRECATED_REVISION_ARGS
                  and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
                  and version.parse(version.parse(SCREAMING_SNAKE_CASE__    ).base_version    ) >= version.parse("""0.20.0"""    )
              ):
                     try:
                            lowercase							:					Any	     =				hf_hub_download(
                                SCREAMING_SNAKE_CASE__ ,     filename=_add_variant(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ) ,     cache_dir=SCREAMING_SNAKE_CASE__ ,     force_download=SCREAMING_SNAKE_CASE__ ,     proxies=SCREAMING_SNAKE_CASE__ ,     resume_download=SCREAMING_SNAKE_CASE__ ,     local_files_only=SCREAMING_SNAKE_CASE__ ,     use_auth_token=SCREAMING_SNAKE_CASE__ ,     user_agent=SCREAMING_SNAKE_CASE__ ,     subfolder=SCREAMING_SNAKE_CASE__ ,     revision=revision or commit_hash ,     )
                            warnings.warn(
                                f"Loading the variant {revision} from {pretrained_model_name_or_path} via `revision='{revision}'` is deprecated. Loading instead from `revision='main'` with `variant={revision}`. Loading model variants via `revision='{revision}'` will be removed in diffusers v1. Please use `variant='{revision}'` instead." ,     SCREAMING_SNAKE_CASE__ ,     )
                            return model_file
                     except:  # noqa: E722
                            warnings.warn(
                                f"You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision='{revision}'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant='{revision}'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )} file in the 'main' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title '{pretrained_model_name_or_path} is missing {_add_variant(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )}' so that the correct variant file can be added." ,     SCREAMING_SNAKE_CASE__ ,     )
              try:
                     # 2. Load model file as usual
                     lowercase							:					int	     =				hf_hub_download(
                         SCREAMING_SNAKE_CASE__ ,     filename=SCREAMING_SNAKE_CASE__ ,     cache_dir=SCREAMING_SNAKE_CASE__ ,     force_download=SCREAMING_SNAKE_CASE__ ,     proxies=SCREAMING_SNAKE_CASE__ ,     resume_download=SCREAMING_SNAKE_CASE__ ,     local_files_only=SCREAMING_SNAKE_CASE__ ,     use_auth_token=SCREAMING_SNAKE_CASE__ ,     user_agent=SCREAMING_SNAKE_CASE__ ,     subfolder=SCREAMING_SNAKE_CASE__ ,     revision=revision or commit_hash ,     )
                     return model_file

              except RepositoryNotFoundError:
                     raise EnvironmentError(
                         f"{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier "
                         """listed on 'https://huggingface.co/models'\nIf this is a private repository, make sure to pass a """
                         """token having permission to this repo with `use_auth_token` or log in with `huggingface-cli """
                         """login`."""    )
              except RevisionNotFoundError:
                     raise EnvironmentError(
                         f"{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for "
                         """this model name. Check the model page at """
                         f"'https://huggingface.co/{pretrained_model_name_or_path}' for available revisions."    )
              except EntryNotFoundError:
                     raise EnvironmentError(
                         f"{pretrained_model_name_or_path} does not appear to have a file named {weights_name}."    )
              except HTTPError as err:
                     raise EnvironmentError(
                         f"There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}"    )
              except ValueError:
                     raise EnvironmentError(
                         f"We couldn't connect to '{HUGGINGFACE_CO_RESOLVE_ENDPOINT}' to load this model, couldn't find it"
                         f" in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a"
                         f" directory containing a file named {weights_name} or"
                         """ \nCheckout your internet connection or see how to run the library in"""
                         """ offline mode at 'https://huggingface.co/docs/diffusers/installation#offline-mode'."""    )
              except EnvironmentError:
                     raise EnvironmentError(
                         f"Can't load the model for '{pretrained_model_name_or_path}'. If you were trying to load it from "
                         """'https://huggingface.co/models', make sure you don't have a local directory with the same name. """
                         f"Otherwise, make sure '{pretrained_model_name_or_path}' is the correct path to a directory "
                         f"containing a file named {weights_name}"    )
