

import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import (
     MODEL_MAPPING,
     BeitForImageClassification,
     BeitForMaskedImageModeling,
     BeitForSemanticSegmentation,
     BeitModel,
 )
 from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 import PIL
 from PIL import Image

 from transformers import BeitImageProcessor
class 						_A :






  def __init__(  self		:     List[str]				,						_A		:     str				,						_A		:     str=100				,						_A		:     Optional[int]=13				,						_A		:     Optional[Any]=30				,						_A		:     Optional[int]=2				,						_A		:     Tuple=3				,						_A		:     Tuple=True				,						_A		:     Optional[int]=True				,						_A		:     List[Any]=32				,						_A		:     Dict=4				,						_A		:     Tuple=4				,						_A		:     Optional[Any]=37				,						_A		:     str="gelu"				,						_A		:     Optional[int]=0.1				,						_A		:     List[str]=0.1				,						_A		:     Any=10				,						_A		:     List[str]=0.02				,						_A		:     str=3				,						_A		:     Union[str, Any]=None				,						_A		:     str=[0, 1, 2, 3]				,						)		->   Optional[Any]:






       """simple docstring"""







       lowercase :       Optional[Any]       =			parent
       lowercase :       Optional[Any]       =			100
       lowercase :       int       =			batch_size
       lowercase :       List[str]       =			image_size
       lowercase :       str       =			patch_size
       lowercase :       Tuple       =			num_channels
       lowercase :       Tuple       =			is_training
       lowercase :       Union[str, Any]       =			use_labels
       lowercase :       int       =			hidden_size
       lowercase :       Any       =			num_hidden_layers
       lowercase :       str       =			num_attention_heads
       lowercase :       List[str]       =			intermediate_size
       lowercase :       Union[str, Any]       =			hidden_act
       lowercase :       Optional[int]       =			hidden_dropout_prob
       lowercase :       int       =			attention_probs_dropout_prob
       lowercase :       List[str]       =			type_sequence_label_size
       lowercase :       int       =			initializer_range
       lowercase :       List[Any]       =			scope
       lowercase :       str       =			out_indices
       lowercase :       Optional[Any]       =			num_labels

       # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
       lowercase :       List[str]       =			(image_size // patch_size) ** 2
       lowercase :       List[str]       =			num_patches + 1






  def  __a      (  self		:     int				)		->   Dict:






       """simple docstring"""







       lowercase :       List[str]       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

       lowercase :       Dict       =			None
       lowercase :       Any       =			None
       if self.use_labels:
            lowercase :       Tuple       =			ids_tensor([self.batch_size]				,						self.type_sequence_label_size				)
            lowercase :       str       =			ids_tensor([self.batch_size, self.image_size, self.image_size]				,						self.num_labels				)

       lowercase :       Optional[int]       =			self.get_config()

       return config, pixel_values, labels, pixel_labels






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






       """simple docstring"""







       return BeitConfig(
           vocab_size=self.vocab_size				,						image_size=self.image_size				,						patch_size=self.patch_size				,						num_channels=self.num_channels				,						hidden_size=self.hidden_size				,						num_hidden_layers=self.num_hidden_layers				,						num_attention_heads=self.num_attention_heads				,						intermediate_size=self.intermediate_size				,						hidden_act=self.hidden_act				,						hidden_dropout_prob=self.hidden_dropout_prob				,						attention_probs_dropout_prob=self.attention_probs_dropout_prob				,						is_decoder=_A				,						initializer_range=self.initializer_range				,						out_indices=self.out_indices				,						)






  def  __a      (  self		:     Optional[Any]				,						_A		:     Tuple				,						_A		:     Optional[Any]				,						_A		:     int				,						_A		:     Any				)		->   Union[str, Any]:






       """simple docstring"""







       lowercase :       List[str]       =			BeitModel(config=_A				)
       model.to(_A				)
       model.eval()
       lowercase :       int       =			model(_A				)
       self.parent.assertEqual(result.last_hidden_state.shape				,						(self.batch_size, self.seq_length, self.hidden_size)				)






  def  __a      (  self		:     str				,						_A		:     Optional[Any]				,						_A		:     Union[str, Any]				,						_A		:     List[str]				,						_A		:     Dict				)		->   Dict:






       """simple docstring"""







       lowercase :       str       =			BeitForMaskedImageModeling(config=_A				)
       model.to(_A				)
       model.eval()
       lowercase :       int       =			model(_A				)
       self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.seq_length - 1, self.vocab_size)				)






  def  __a      (  self		:     Any				,						_A		:     Dict				,						_A		:     Any				,						_A		:     Any				,						_A		:     List[Any]				)		->   str:






       """simple docstring"""







       lowercase :       List[str]       =			self.type_sequence_label_size
       lowercase :       Tuple       =			BeitForImageClassification(_A				)
       model.to(_A				)
       model.eval()
       lowercase :       Any       =			model(_A				,						labels=_A				)
       self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.type_sequence_label_size)				)

       # test greyscale images
       lowercase :       List[str]       =			1
       lowercase :       int       =			BeitForImageClassification(_A				)
       model.to(_A				)
       model.eval()

       lowercase :       Optional[int]       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
       lowercase :       Union[str, Any]       =			model(_A				,						labels=_A				)
       self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.type_sequence_label_size)				)






  def  __a      (  self		:     Optional[Any]				,						_A		:     Tuple				,						_A		:     Tuple				,						_A		:     List[Any]				,						_A		:     Union[str, Any]				)		->   List[Any]:






       """simple docstring"""







       lowercase :       str       =			self.num_labels
       lowercase :       Tuple       =			BeitForSemanticSegmentation(_A				)
       model.to(_A				)
       model.eval()
       lowercase :       List[Any]       =			model(_A				)
       self.parent.assertEqual(
           result.logits.shape				,						(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)				)
       lowercase :       Union[str, Any]       =			model(_A				,						labels=_A				)
       self.parent.assertEqual(
           result.logits.shape				,						(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)				)






  def  __a      (  self		:     Optional[Any]				)		->   int:






       """simple docstring"""







       lowercase :       int       =			self.prepare_config_and_inputs()
       lowercase :       List[Any]       =			config_and_inputs
       lowercase :       List[Any]       =			{'''pixel_values''': pixel_values}
       return config, inputs_dict


@require_torch
class 						_A (  _lowerCamelCase      ,       _lowerCamelCase      ,       unittest.TestCase				):
  _UpperCamelCase       :      str			=      (
      (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
      if is_torch_available()
      else ()
  )
  _UpperCamelCase       :      str			=      (
      {
          '''feature-extraction''': BeitModel,
          '''image-classification''': BeitForImageClassification,
          '''image-segmentation''': BeitForSemanticSegmentation,
      }
      if is_torch_available()
      else {}
  )

  _UpperCamelCase       :      Union[str, Any]			=      False
  _UpperCamelCase       :      List[Any]			=      False
  _UpperCamelCase       :      Dict			=      False






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






       """simple docstring"""







       lowercase :       List[str]       =			BeitModelTester(self				)
       lowercase :       str       =			ConfigTester(self				,						config_class=_A				,						has_text_modality=_A				,						hidden_size=37				)






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






       """simple docstring"""







       self.config_tester.run_common_tests()






  @unittest.skip(reason='''BEiT does not use inputs_embeds'''				)
  def  __a      (  self		:     Optional[Any]				)		->   List[str]:






       """simple docstring"""







       pass






  @require_torch_multi_gpu
  @unittest.skip(reason='''BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''				)
  def  __a      (  self		:     Union[str, Any]				)		->   Optional[int]:






       """simple docstring"""







       pass






  def  __a      (  self		:     Optional[Any]				)		->   Dict:






       """simple docstring"""







       lowercase :       Dict       =			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            lowercase :       List[str]       =			model_class(_A				)
            self.assertIsInstance(model.get_input_embeddings()				,						(nn.Module)				)
            lowercase :       List[str]       =			model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(_A				,						nn.Linear				)				)






  def  __a      (  self		:     List[Any]				)		->   List[Any]:






       """simple docstring"""







       lowercase :       Any       =			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            lowercase :       Union[str, Any]       =			model_class(_A				)
            lowercase :       List[str]       =			inspect.signature(model.forward				)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            lowercase :       List[str]       =			[*signature.parameters.keys()]

            lowercase :       Optional[int]       =			['''pixel_values''']
            self.assertListEqual(arg_names[:1]				,						_A				)






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






       """simple docstring"""







       lowercase :       Optional[int]       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A				)






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






       """simple docstring"""







       lowercase :       Any       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_A				)






  def  __a      (  self		:     Tuple				)		->   Tuple:






       """simple docstring"""







       lowercase :       int       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_A				)






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






       """simple docstring"""







       lowercase :       List[Any]       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_semantic_segmentation(*_A				)






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






       """simple docstring"""







       if not self.model_tester.is_training:
            return

       lowercase :       List[str]       =			self.model_tester.prepare_config_and_inputs_for_common()
       lowercase :       Tuple       =			True

       for model_class in self.all_model_classes:
            # we don't test BeitForMaskedImageModeling
            if model_class in [*get_values(_A				), BeitForMaskedImageModeling]:
                 continue

            lowercase :       List[Any]       =			model_class(_A				)
            model.to(_A				)
            model.train()
            lowercase :       Optional[Any]       =			self._prepare_for_class(_A				,						_A				,						return_labels=_A				)
            lowercase :       Any       =			model(**_A				).loss
            loss.backward()






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






       """simple docstring"""







       lowercase :       Dict       =			self.model_tester.prepare_config_and_inputs_for_common()
       if not self.model_tester.is_training:
            return

       lowercase :       List[Any]       =			False
       lowercase :       Optional[int]       =			True

       for model_class in self.all_model_classes:
            # we don't test BeitForMaskedImageModeling
            if (
                model_class in [*get_values(_A				), BeitForMaskedImageModeling]
                or not model_class.supports_gradient_checkpointing
            ):
                 continue

            lowercase :       List[str]       =			model_class(_A				)
            model.gradient_checkpointing_enable()
            model.to(_A				)
            model.train()
            lowercase :       Dict       =			self._prepare_for_class(_A				,						_A				,						return_labels=_A				)
            lowercase :       Any       =			model(**_A				).loss
            loss.backward()






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






       """simple docstring"""







       lowercase :       List[str]       =			self.model_tester.prepare_config_and_inputs_for_common()

       lowercase :       Tuple       =			_config_zero_init(_A				)
       for model_class in self.all_model_classes:
            lowercase :       int       =			model_class(config=_A				)
            for name, param in model.named_parameters():
                 # we skip lambda parameters as these require special initial values
                 # determined by config.layer_scale_init_value
                 if "lambda" in name:
                      continue
                 if param.requires_grad:
                      self.assertIn(
                          ((param.data.mean() * 1E9).round() / 1E9).item()				,						[0.0, 1.0]				,						msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""				,						)






  @slow
  def  __a      (  self		:     str				)		->   int:






       """simple docstring"""







       for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            lowercase :       Union[str, Any]       =			BeitModel.from_pretrained(_A				)
            self.assertIsNotNone(_A				)






def  snake_case(    )			->							int:





     '''simple docstring'''


     lowercase :       Dict       =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
     return image



@require_torch
@require_vision
class 						_A (  unittest.TestCase				):






  @cached_property
  def  __a      (  self		:     Tuple				)		->   str:






       """simple docstring"""







       return BeitImageProcessor.from_pretrained('''microsoft/beit-base-patch16-224'''				) if is_vision_available() else None






  @slow
  def  __a      (  self		:     Tuple				)		->   int:






       """simple docstring"""







       lowercase :       List[str]       =			BeitForMaskedImageModeling.from_pretrained('''microsoft/beit-base-patch16-224-pt22k'''				).to(_A				)

       lowercase :       Any       =			self.default_image_processor
       lowercase :       Union[str, Any]       =			prepare_img()
       lowercase :       Optional[Any]       =			image_processor(images=_A				,						return_tensors='''pt'''				).pixel_values.to(_A				)

       # prepare bool_masked_pos
       lowercase :       List[Any]       =			torch.ones((1, 196)				,						dtype=torch.bool				).to(_A				)

       # forward pass
       with torch.no_grad():
            lowercase :       Union[str, Any]       =			model(pixel_values=_A				,						bool_masked_pos=_A				)
       lowercase :       List[Any]       =			outputs.logits

       # verify the logits
       lowercase :       Union[str, Any]       =			torch.Size((1, 196, 8_192)				)
       self.assertEqual(logits.shape				,						_A				)

       lowercase :       str       =			torch.tensor(
           [[-3.2_437, 0.5_072, -13.9_174], [-3.2_456, 0.4_948, -13.9_401], [-3.2_033, 0.5_121, -13.8_550]]				).to(_A				)

       self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]				,						_A				,						atol=1E-2				)				)






  @slow
  def  __a      (  self		:     Dict				)		->   Any:






       """simple docstring"""







       lowercase :       Any       =			BeitForImageClassification.from_pretrained('''microsoft/beit-base-patch16-224'''				).to(_A				)

       lowercase :       List[Any]       =			self.default_image_processor
       lowercase :       List[str]       =			prepare_img()
       lowercase :       List[Any]       =			image_processor(images=_A				,						return_tensors='''pt'''				).to(_A				)

       # forward pass
       with torch.no_grad():
            lowercase :       List[Any]       =			model(**_A				)
       lowercase :       Tuple       =			outputs.logits

       # verify the logits
       lowercase :       List[Any]       =			torch.Size((1, 1_000)				)
       self.assertEqual(logits.shape				,						_A				)

       lowercase :       str       =			torch.tensor([-1.2_385, -1.0_987, -1.0_108]				).to(_A				)

       self.assertTrue(torch.allclose(logits[0, :3]				,						_A				,						atol=1E-4				)				)

       lowercase :       List[Any]       =			281
       self.assertEqual(logits.argmax(-1				).item()				,						_A				)






  @slow
  def  __a      (  self		:     Tuple				)		->   Any:






       """simple docstring"""







       lowercase :       Optional[Any]       =			BeitForImageClassification.from_pretrained('''microsoft/beit-large-patch16-224-pt22k-ft22k'''				).to(
           _A				)

       lowercase :       str       =			self.default_image_processor
       lowercase :       List[str]       =			prepare_img()
       lowercase :       Tuple       =			image_processor(images=_A				,						return_tensors='''pt'''				).to(_A				)

       # forward pass
       with torch.no_grad():
            lowercase :       List[Any]       =			model(**_A				)
       lowercase :       Any       =			outputs.logits

       # verify the logits
       lowercase :       Optional[int]       =			torch.Size((1, 21_841)				)
       self.assertEqual(logits.shape				,						_A				)

       lowercase :       Any       =			torch.tensor([1.6_881, -0.2_787, 0.5_901]				).to(_A				)

       self.assertTrue(torch.allclose(logits[0, :3]				,						_A				,						atol=1E-4				)				)

       lowercase :       Dict       =			2_396
       self.assertEqual(logits.argmax(-1				).item()				,						_A				)






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






       """simple docstring"""







       lowercase :       Union[str, Any]       =			BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''				)
       lowercase :       Any       =			model.to(_A				)

       lowercase :       Tuple       =			BeitImageProcessor(do_resize=_A				,						size=640				,						do_center_crop=_A				)

       lowercase :       Union[str, Any]       =			load_dataset('''hf-internal-testing/fixtures_ade20k'''				,						split='''test'''				)
       lowercase :       List[str]       =			Image.open(ds[0]['''file''']				)
       lowercase :       Optional[int]       =			image_processor(images=_A				,						return_tensors='''pt'''				).to(_A				)

       # forward pass
       with torch.no_grad():
            lowercase :       Any       =			model(**_A				)
       lowercase :       Tuple       =			outputs.logits

       # verify the logits
       lowercase :       str       =			torch.Size((1, 150, 160, 160)				)
       self.assertEqual(logits.shape				,						_A				)

       lowercase :       Optional[Any]       =			version.parse(PIL.__version__				) < version.parse('''9.0.0'''				)

       if is_pillow_less_than_a:
            lowercase :       int       =			torch.tensor(
                [
                    [[-4.9_225, -2.3_954, -3.0_522], [-2.8_822, -1.0_046, -1.7_561], [-2.9_549, -1.3_228, -2.1_347]],
                    [[-5.8_168, -3.4_129, -4.0_778], [-3.8_651, -2.2_214, -3.0_277], [-3.8_356, -2.4_643, -3.3_535]],
                    [[-0.0_078, 3.9_952, 4.0_754], [2.9_856, 4.6_944, 5.0_035], [3.2_413, 4.7_813, 4.9_969]],
                ]				,						device=_A				,						)
       else:
            lowercase :       Dict       =			torch.tensor(
                [
                    [[-4.8_960, -2.3_688, -3.0_355], [-2.8_478, -0.9_836, -1.7_418], [-2.9_449, -1.3_332, -2.1_456]],
                    [[-5.8_081, -3.4_124, -4.1_006], [-3.8_561, -2.2_081, -3.0_323], [-3.8_365, -2.4_601, -3.3_669]],
                    [[-0.0_309, 3.9_868, 4.0_540], [2.9_640, 4.6_877, 4.9_976], [3.2_081, 4.7_690, 4.9_942]],
                ]				,						device=_A				,						)

       self.assertTrue(torch.allclose(logits[0, :3, :3, :3]				,						_A				,						atol=1E-4				)				)






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






       """simple docstring"""







       lowercase :       List[str]       =			BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''				)
       lowercase :       Any       =			model.to(_A				)

       lowercase :       Optional[Any]       =			BeitImageProcessor(do_resize=_A				,						size=640				,						do_center_crop=_A				)

       lowercase :       Any       =			load_dataset('''hf-internal-testing/fixtures_ade20k'''				,						split='''test'''				)
       lowercase :       Dict       =			Image.open(ds[0]['''file''']				)
       lowercase :       List[str]       =			image_processor(images=_A				,						return_tensors='''pt'''				).to(_A				)

       # forward pass
       with torch.no_grad():
            lowercase :       Optional[int]       =			model(**_A				)

       lowercase :       List[Any]       =			outputs.logits.detach().cpu()

       lowercase :       Optional[int]       =			image_processor.post_process_semantic_segmentation(outputs=_A				,						target_sizes=[(500, 300)]				)
       lowercase :       Union[str, Any]       =			torch.Size((500, 300)				)
       self.assertEqual(segmentation[0].shape				,						_A				)

       lowercase :       Optional[int]       =			image_processor.post_process_semantic_segmentation(outputs=_A				)
       lowercase :       Any       =			torch.Size((160, 160)				)
       self.assertEqual(segmentation[0].shape				,						_A				)





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


lowerCAmelCase_						=			get_logger(__name__)


lowerCAmelCase_						=			Path(__file__).parent / 'model_card_template.md'
lowerCAmelCase_						=			uuida().hex
lowerCAmelCase_						=			os.getenv('HF_HUB_OFFLINE', '').upper() in ENV_VARS_TRUE_VALUES
lowerCAmelCase_						=			os.getenv('DISABLE_TELEMETRY', '').upper() in ENV_VARS_TRUE_VALUES
lowerCAmelCase_						=			HUGGINGFACE_CO_RESOLVE_ENDPOINT + '/api/telemetry/'






def  snake_case(    __magic_name__ = None   )			->							str:





     '''simple docstring'''


     lowercase :       List[Any]       =			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(__magic_name__			,		__magic_name__   ):
          ua += "; " + "; ".join(F"""{k}/{v}""" for k, v in user_agent.items()   )
     elif isinstance(__magic_name__			,		__magic_name__   ):
          ua += "; " + user_agent
     return ua






def  snake_case(    __magic_name__			,		__magic_name__ = None			,		__magic_name__ = None   )			->							Optional[Any]:





     '''simple docstring'''


     if token is None:
          lowercase :       int       =			HfFolder.get_token()
     if organization is None:
          lowercase :       List[str]       =			whoami(__magic_name__   )['''name''']
          return F"""{username}/{model_id}"""
     else:
          return F"""{organization}/{model_id}"""






def  snake_case(    __magic_name__			,		__magic_name__   )			->							Union[str, Any]:





     '''simple docstring'''


     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(__magic_name__			,		'''local_rank'''   ) and args.local_rank not in [-1, 0]:
          return

     lowercase :       Optional[Any]       =			args.hub_token if hasattr(__magic_name__			,		'''hub_token'''   ) else None
     lowercase :       int       =			get_full_repo_name(__magic_name__			,		token=__magic_name__   )

     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=__magic_name__			,		model_name=__magic_name__			,		repo_name=__magic_name__			,		dataset_name=args.dataset_name if hasattr(__magic_name__			,		'''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(__magic_name__			,		'''gradient_accumulation_steps'''   ) else None
         )			,		adam_betaa=args.adam_betaa if hasattr(__magic_name__			,		'''adam_beta1'''   ) else None			,		adam_betaa=args.adam_betaa if hasattr(__magic_name__			,		'''adam_beta2'''   ) else None			,		adam_weight_decay=args.adam_weight_decay if hasattr(__magic_name__			,		'''adam_weight_decay'''   ) else None			,		adam_epsilon=args.adam_epsilon if hasattr(__magic_name__			,		'''adam_epsilon'''   ) else None			,		lr_scheduler=args.lr_scheduler if hasattr(__magic_name__			,		'''lr_scheduler'''   ) else None			,		lr_warmup_steps=args.lr_warmup_steps if hasattr(__magic_name__			,		'''lr_warmup_steps'''   ) else None			,		ema_inv_gamma=args.ema_inv_gamma if hasattr(__magic_name__			,		'''ema_inv_gamma'''   ) else None			,		ema_power=args.ema_power if hasattr(__magic_name__			,		'''ema_power'''   ) else None			,		ema_max_decay=args.ema_max_decay if hasattr(__magic_name__			,		'''ema_max_decay'''   ) else None			,		mixed_precision=args.mixed_precision			,		)

     lowercase :       Any       =			os.path.join(args.output_dir			,		'''README.md'''   )
     model_card.save(__magic_name__   )






def  snake_case(    __magic_name__			,		__magic_name__ = None   )			->							int:





     '''simple docstring'''


     if resolved_file is None or commit_hash is not None:
          return commit_hash
     lowercase :       Dict       =			str(Path(__magic_name__   ).as_posix()   )
     lowercase :       Any       =			re.search(r'''snapshots/([^/]+)/'''			,		__magic_name__   )
     if search is None:
          return None
     lowercase :       List[Any]       =			search.groups()[0]
     return commit_hash if REGEX_COMMIT_HASH.match(__magic_name__   ) 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.
lowerCAmelCase_						=			os.path.expanduser(
    os.getenv('HF_HOME', os.path.join(os.getenv('XDG_CACHE_HOME', '~/.cache'), 'huggingface'))
)
lowerCAmelCase_						=			os.path.join(hf_cache_home, 'diffusers')






def  snake_case(    __magic_name__ = None			,		__magic_name__ = None   )			->							None:





     '''simple docstring'''


     if new_cache_dir is None:
          lowercase :       str       =			DIFFUSERS_CACHE
     if old_cache_dir is None:
          lowercase :       List[str]       =			old_diffusers_cache

     lowercase :       str       =			Path(__magic_name__   ).expanduser()
     lowercase :       Dict       =			Path(__magic_name__   ).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 :       List[Any]       =			new_cache_dir / old_blob_path.relative_to(__magic_name__   )
               new_blob_path.parent.mkdir(parents=__magic_name__			,		exist_ok=__magic_name__   )
               os.replace(__magic_name__			,		__magic_name__   )
               try:
                    os.symlink(__magic_name__			,		__magic_name__   )
               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).


lowerCAmelCase_						=			os.path.join(DIFFUSERS_CACHE, 'version_diffusers_cache.txt')
if not os.path.isfile(cache_version_file):
 lowerCAmelCase_						=			0
else:
 with open(cache_version_file) as f:
  try:
   lowerCAmelCase_						=			int(f.read())
  except ValueError:
   lowerCAmelCase_						=			0

if cache_version < 1:
 lowerCAmelCase_						=			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:
   lowerCAmelCase_						=			'\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(    __magic_name__			,		__magic_name__ = None   )			->							str:





     '''simple docstring'''


     if variant is not None:
          lowercase :       List[str]       =			weights_name.split('''.'''   )
          lowercase :       Any       =			splits[:-1] + [variant] + splits[-1:]
          lowercase :       Tuple       =			'''.'''.join(__magic_name__   )

     return weights_name






def  snake_case(    __magic_name__			,		*,
    __magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__=None			,		)			->							Dict:





     '''simple docstring'''


     lowercase :       Union[str, Any]       =			str(__magic_name__   )
     if os.path.isfile(__magic_name__   ):
          return pretrained_model_name_or_path
     elif os.path.isdir(__magic_name__   ):
          if os.path.isfile(os.path.join(__magic_name__			,		__magic_name__   )   ):
               # Load from a PyTorch checkpoint
               lowercase :       Dict       =			os.path.join(__magic_name__			,		__magic_name__   )
               return model_file
          elif subfolder is not None and os.path.isfile(
              os.path.join(__magic_name__			,		__magic_name__			,		__magic_name__   )   ):
               lowercase :       str       =			os.path.join(__magic_name__			,		__magic_name__			,		__magic_name__   )
               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(__magic_name__   ).base_version   ) >= version.parse('''0.20.0'''   )
          ):
               try:
                    lowercase :       int       =			hf_hub_download(
                        __magic_name__			,		filename=_add_variant(__magic_name__			,		__magic_name__   )			,		cache_dir=__magic_name__			,		force_download=__magic_name__			,		proxies=__magic_name__			,		resume_download=__magic_name__			,		local_files_only=__magic_name__			,		use_auth_token=__magic_name__			,		user_agent=__magic_name__			,		subfolder=__magic_name__			,		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."""			,		__magic_name__			,		)
                    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(__magic_name__			,		__magic_name__   )} 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(__magic_name__			,		__magic_name__   )}' so that the correct variant file can be added."""			,		__magic_name__			,		)
          try:
               # 2. Load model file as usual
               lowercase :       Dict       =			hf_hub_download(
                   __magic_name__			,		filename=__magic_name__			,		cache_dir=__magic_name__			,		force_download=__magic_name__			,		proxies=__magic_name__			,		resume_download=__magic_name__			,		local_files_only=__magic_name__			,		use_auth_token=__magic_name__			,		user_agent=__magic_name__			,		subfolder=__magic_name__			,		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}"""   )