




"""simple docstring"""







import json
import os
import shutil
import tempfile
import unittest

from transformers import BatchEncoding, CanineTokenizer
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.tokenization_utils import AddedToken
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin




class       lowerCAmelCase__       (			lowerCAmelCase_  ,			unittest.TestCase    ):


				"""simple docstring"""





				__UpperCAmelCase :     Tuple       =      CanineTokenizer
				__UpperCAmelCase :     Any       =      False



				def       snake_case    (     self					:	Optional[Any]						):
						super().setUp()
						__lowercase				:		int												=				CanineTokenizer()
						tokenizer.save_pretrained(self.tmpdirname						)



				@cached_property
				def       snake_case    (     self					:	Any						):
						return CanineTokenizer.from_pretrained("google/canine-s"						)



				def       snake_case    (     self					:	int    ,   **lowercase__					:	Optional[Any]						):
						__lowercase				:		int												=				self.tokenizer_class.from_pretrained(self.tmpdirname    ,   **lowercase__						)
						__lowercase				:		Optional[int]												=				1_0_2_4
						return tokenizer



				@require_torch
				def       snake_case    (     self					:	str						):
						__lowercase				:		Tuple												=				self.canine_tokenizer
						__lowercase				:		str												=				["Life is like a box of chocolates.", "You never know what you're gonna get."]
						# fmt: off
						__lowercase				:		Any												=				[5_7_3_4_4, 7_6, 1_0_5, 1_0_2, 1_0_1, 3_2, 1_0_5, 1_1_5, 3_2, 1_0_8, 1_0_5, 1_0_7, 1_0_1, 3_2, 9_7, 3_2, 9_8, 1_1_1, 1_2_0, 3_2, 1_1_1, 1_0_2, 3_2, 9_9, 1_0_4, 1_1_1, 9_9, 1_1_1, 1_0_8, 9_7, 1_1_6, 1_0_1, 1_1_5, 4_6, 5_7_3_4_5, 0, 0, 0, 0]
						# fmt: on
						__lowercase				:		Union[str, Any]												=				tokenizer(lowercase__    ,   padding=lowercase__    ,   return_tensors="pt"						)
						self.assertIsInstance(lowercase__    ,   lowercase__						)

						__lowercase				:		List[Any]												=				list(batch.input_ids.numpy()[0]						)

						self.assertListEqual(lowercase__    ,   lowercase__						)

						self.assertEqual((2, 3_9)    ,   batch.input_ids.shape						)
						self.assertEqual((2, 3_9)    ,   batch.attention_mask.shape						)



				@require_torch
				def       snake_case    (     self					:	int						):
						__lowercase				:		Optional[int]												=				self.canine_tokenizer
						__lowercase				:		Optional[Any]												=				["Once there was a man.", "He wrote a test in HuggingFace Tranformers."]
						__lowercase				:		Tuple												=				tokenizer(lowercase__    ,   padding=lowercase__    ,   return_tensors="pt"						)
						# check if input_ids, attention_mask and token_type_ids are returned
						self.assertIn("input_ids"    ,   lowercase__						)
						self.assertIn("attention_mask"    ,   lowercase__						)
						self.assertIn("token_type_ids"    ,   lowercase__						)



				@require_torch
				def       snake_case    (     self					:	Union[str, Any]						):
						__lowercase				:		Tuple												=				self.canine_tokenizer
						__lowercase				:		List[Any]												=				[
						    "What's the weater?",
						    "It's about 25 degrees.",
						]
						__lowercase				:		Optional[int]												=				tokenizer(
						    text_target=lowercase__    ,   max_length=3_2    ,   padding="max_length"    ,   truncation=lowercase__    ,   return_tensors="pt"						)
						self.assertEqual(3_2    ,   targets["input_ids"].shape[1]						)



				def       snake_case    (     self					:	Dict						):
						# safety check on max_len default value so we are sure the test works
						__lowercase				:		Tuple												=				self.get_tokenizers()
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										self.assertNotEqual(tokenizer.model_max_length    ,   4_2						)

        # Now let's start the test
						__lowercase				:		Any												=				self.get_tokenizers()
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										# Isolate this from the other tests because we save additional tokens/etc
										__lowercase				:		int												=				tempfile.mkdtemp()

										__lowercase				:		Optional[int]												=				" He is very happy, UNwant\u00E9d,running"
										__lowercase				:		List[str]												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										tokenizer.save_pretrained(lowercase__						)

										__lowercase				:		List[Any]												=				tokenizer.__class__.from_pretrained(lowercase__						)
										__lowercase				:		Optional[int]												=				after_tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										self.assertListEqual(lowercase__    ,   lowercase__						)

										shutil.rmtree(lowercase__						)

						__lowercase				:		List[str]												=				self.get_tokenizers(model_max_length=4_2						)
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										# Isolate this from the other tests because we save additional tokens/etc
										__lowercase				:		Union[str, Any]												=				tempfile.mkdtemp()

										__lowercase				:		Dict												=				" He is very happy, UNwant\u00E9d,running"

										__lowercase				:		str												=				tokenizer.additional_special_tokens

										# We can add a new special token for Canine as follows:
										__lowercase				:		Optional[Any]												=				chr(0xE_007						)
										additional_special_tokens.append(lowercase__						)
										tokenizer.add_special_tokens({"additional_special_tokens": additional_special_tokens}						)
										__lowercase				:		Dict												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										tokenizer.save_pretrained(lowercase__						)

										__lowercase				:		Any												=				tokenizer.__class__.from_pretrained(lowercase__						)
										__lowercase				:		Tuple												=				after_tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										self.assertListEqual(lowercase__    ,   lowercase__						)
										self.assertIn(lowercase__    ,   after_tokenizer.additional_special_tokens						)
										self.assertEqual(after_tokenizer.model_max_length    ,   4_2						)

										__lowercase				:		str												=				tokenizer.__class__.from_pretrained(lowercase__    ,   model_max_length=4_3						)
										self.assertEqual(tokenizer.model_max_length    ,   4_3						)

										shutil.rmtree(lowercase__						)



				def       snake_case    (     self					:	List[str]						):
						__lowercase				:		List[str]												=				self.get_tokenizers(do_lower_case=lowercase__						)
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										__lowercase						,__lowercase				:		Union[str, Any]												=				self.get_clean_sequence(lowercase__						)

										# a special token for Canine can be defined as follows:
										__lowercase				:		Tuple												=				0xE_005
										__lowercase				:		Dict												=				chr(lowercase__						)

										tokenizer.add_special_tokens({"cls_token": special_token}						)
										__lowercase				:		str												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										self.assertEqual(len(lowercase__						)    ,   1						)

										__lowercase				:		int												=				tokenizer.decode(ids + encoded_special_token    ,   clean_up_tokenization_spaces=lowercase__						)
										__lowercase				:		str												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)

										__lowercase				:		List[str]												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										__lowercase				:		Dict												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										self.assertEqual(lowercase__    ,   input_encoded + special_token_id						)

										__lowercase				:		Tuple												=				tokenizer.decode(lowercase__    ,   skip_special_tokens=lowercase__						)
										self.assertTrue(special_token not in decoded						)



				def       snake_case    (     self					:	List[Any]						):
						__lowercase				:		int												=				self.get_tokenizers(do_lower_case=lowercase__						)
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										__lowercase				:		Optional[int]												=				chr(0xE_005						)
										__lowercase				:		List[Any]												=				chr(0xE_006						)

										# `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py)
										tokenizer.add_tokens([SPECIAL_TOKEN_1]    ,   special_tokens=lowercase__						)
										# `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`,
										# which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py)
										tokenizer.add_special_tokens({"additional_special_tokens": [SPECIAL_TOKEN_2]}						)

										__lowercase				:		Dict												=				tokenizer.tokenize(lowercase__						)
										__lowercase				:		Optional[Any]												=				tokenizer.tokenize(lowercase__						)

										self.assertEqual(len(lowercase__						)    ,   1						)
										self.assertEqual(len(lowercase__						)    ,   1						)
										self.assertEqual(token_a[0]    ,   lowercase__						)
										self.assertEqual(token_a[0]    ,   lowercase__						)



				@require_tokenizers
				def       snake_case    (     self					:	str						):
						__lowercase				:		Union[str, Any]												=				self.get_tokenizers(do_lower_case=lowercase__						)
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										# a special token for Canine can be defined as follows:
										__lowercase				:		Any												=				0xE_006
										__lowercase				:		Dict												=				chr(lowercase__						)

										__lowercase				:		List[str]												=				AddedToken(lowercase__    ,   lstrip=lowercase__						)
										tokenizer.add_special_tokens({"additional_special_tokens": [new_token]}						)

										with tempfile.TemporaryDirectory() as tmp_dir_name:
												tokenizer.save_pretrained(lowercase__						)
												tokenizer.from_pretrained(lowercase__						)



				def       snake_case    (     self					:	Tuple						):
						__lowercase				:		List[str]												=				[]
						if self.test_slow_tokenizer:
								tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

						if self.test_rust_tokenizer:
								tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

						for tokenizer_class, tokenizer_utils in tokenizer_list:
								with tempfile.TemporaryDirectory() as tmp_dir:
										tokenizer_utils.save_pretrained(lowercase__						)

										with open(os.path.join(lowercase__    ,   "special_tokens_map.json"						)    ,   encoding="utf-8"						) as json_file:
												__lowercase				:		Tuple												=				json.load(lowercase__						)

										with open(os.path.join(lowercase__    ,   "tokenizer_config.json"						)    ,   encoding="utf-8"						) as json_file:
												__lowercase				:		Optional[int]												=				json.load(lowercase__						)

										# a special token for Canine can be defined as follows:
										__lowercase				:		Any												=				0xE_006
										__lowercase				:		Optional[Any]												=				chr(lowercase__						)

										__lowercase				:		Tuple												=				[new_token_a]
										__lowercase				:		Union[str, Any]												=				[new_token_a]

										with open(os.path.join(lowercase__    ,   "special_tokens_map.json"						)    ,   "w"    ,   encoding="utf-8"						) as outfile:
												json.dump(lowercase__    ,   lowercase__						)
										with open(os.path.join(lowercase__    ,   "tokenizer_config.json"						)    ,   "w"    ,   encoding="utf-8"						) as outfile:
												json.dump(lowercase__    ,   lowercase__						)

										# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
										# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
										# "special_tokens_map.json" files
										__lowercase				:		Optional[Any]												=				tokenizer_class.from_pretrained(lowercase__    ,   extra_ids=0						)
										self.assertIn(lowercase__    ,   tokenizer_without_change_in_init.additional_special_tokens						)
										# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
										self.assertEqual(
										    [new_token_a]    ,   tokenizer_without_change_in_init.convert_ids_to_tokens(
										        tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a]						)						)    ,   )

										__lowercase				:		Optional[Any]												=				0xE_007
										__lowercase				:		List[str]												=				chr(lowercase__						)
										# Now we test that we can change the value of additional_special_tokens in the from_pretrained
										__lowercase				:		List[Any]												=				[AddedToken(lowercase__    ,   lstrip=lowercase__						)]
										__lowercase				:		List[str]												=				tokenizer_class.from_pretrained(
										    lowercase__    ,   additional_special_tokens=lowercase__    ,   extra_ids=0						)

										self.assertIn(lowercase__    ,   tokenizer.additional_special_tokens						)
										# self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab
										self.assertEqual(
										    [new_token_a]    ,   tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a]						)						)						)



				@require_tokenizers
				def       snake_case    (     self					:	str						):
						__lowercase				:		int												=				self.get_tokenizers(do_lower_case=lowercase__						)
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										__lowercase				:		Union[str, Any]												=				"hello world"
										if self.space_between_special_tokens:
												__lowercase				:		int												=				"[CLS] hello world [SEP]"
										else:
												__lowercase				:		int												=				input
										__lowercase				:		Tuple												=				tokenizer.encode(lowercase__    ,   add_special_tokens=lowercase__						)
										__lowercase				:		int												=				tokenizer.decode(lowercase__    ,   spaces_between_special_tokens=self.space_between_special_tokens						)
										self.assertIn(lowercase__    ,   [output, output.lower()]						)



				def       snake_case    (     self					:	List[str]						):
						__lowercase				:		Dict												=				self.get_tokenizers()
						for tokenizer in tokenizers:
								with self.subTest(f'{tokenizer.__class__.__name__}'						):
										__lowercase				:		Optional[Any]												=				[
										    "bos_token",
										    "eos_token",
										    "unk_token",
										    "sep_token",
										    "pad_token",
										    "cls_token",
										    "mask_token",
										]

						__lowercase				:		List[Any]												=				"a"
						__lowercase				:		Any												=				ord(lowercase__						)

						for attr in attributes_list:
								setattr(lowercase__    ,   attr + "_id"    ,   lowercase__						)
								self.assertEqual(getattr(lowercase__    ,   lowercase__						)    ,   lowercase__						)
								self.assertEqual(getattr(lowercase__    ,   attr + "_id"						)    ,   lowercase__						)

								setattr(lowercase__    ,   attr + "_id"    ,   lowercase__						)
								self.assertEqual(getattr(lowercase__    ,   lowercase__						)    ,   lowercase__						)
								self.assertEqual(getattr(lowercase__    ,   attr + "_id"						)    ,   lowercase__						)

						setattr(lowercase__    ,   "additional_special_tokens_ids"    ,   []						)
						self.assertListEqual(getattr(lowercase__    ,   "additional_special_tokens"						)    ,   []						)
						self.assertListEqual(getattr(lowercase__    ,   "additional_special_tokens_ids"						)    ,   []						)

						__lowercase				:		Dict												=				0xE_006
						__lowercase				:		List[str]												=				chr(lowercase__						)
						setattr(lowercase__    ,   "additional_special_tokens_ids"    ,   [additional_special_token_id]						)
						self.assertListEqual(getattr(lowercase__    ,   "additional_special_tokens"						)    ,   [additional_special_token]						)
						self.assertListEqual(getattr(lowercase__    ,   "additional_special_tokens_ids"						)    ,   [additional_special_token_id]						)



				def       snake_case    (     self					:	Any						):
						pass



				def       snake_case    (     self					:	str						):
						pass



				def       snake_case    (     self					:	Optional[Any]						):
						pass



				def       snake_case    (     self					:	Tuple						):
						pass



				def       snake_case    (     self					:	Any						):
						pass



				def       snake_case    (     self					:	str						):
						pass



				def       snake_case    (     self					:	Tuple						):
						pass



				def       snake_case    (     self					:	int						):
						pass






"""simple docstring"""







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


__A   :  List[Any]					=      get_logger(__name__)


__A   :  Tuple					=      Path(__file__).parent / 'model_card_template.md'
__A   :  Any					=      uuida().hex
__A   :  Optional[int]					=      os.getenv('HF_HUB_OFFLINE', '').upper() in ENV_VARS_TRUE_VALUES
__A   :  Tuple					=      os.getenv('DISABLE_TELEMETRY', '').upper() in ENV_VARS_TRUE_VALUES
__A   :  List[Any]					=      HUGGINGFACE_CO_RESOLVE_ENDPOINT + '/api/telemetry/'

def 						snake_case__       (					_lowerCamelCase = None				)			->str:






		"""simple docstring"""


		__lowercase				:		Optional[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(_lowerCamelCase,  _lowerCamelCase				):
				ua += "; " + "; ".join(F'{k}/{v}' for k, v in user_agent.items()				)
		elif isinstance(_lowerCamelCase,  _lowerCamelCase				):
				ua += "; " + user_agent
		return ua

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase = None,  _lowerCamelCase = None				)			->List[Any]:






		"""simple docstring"""


		if token is None:
				__lowercase				:		Any												=				HfFolder.get_token()
		if organization is None:
				__lowercase				:		int												=				whoami(_lowerCamelCase				)["name"]
				return F'{username}/{model_id}'
		else:
				return F'{organization}/{model_id}'

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase				)			->Dict:






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

		__lowercase				:		Tuple												=				args.hub_token if hasattr(_lowerCamelCase,  "hub_token"				) else None
		__lowercase				:		int												=				get_full_repo_name(_lowerCamelCase,  token=_lowerCamelCase				)

		__lowercase				:		Optional[Any]												=				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=_lowerCamelCase,  model_name=_lowerCamelCase,  repo_name=_lowerCamelCase,  dataset_name=args.dataset_name if hasattr(_lowerCamelCase,  "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(_lowerCamelCase,  "gradient_accumulation_steps"				) else None
		    ),  adam_betaa=args.adam_betaa if hasattr(_lowerCamelCase,  "adam_beta1"				) else None,  adam_betaa=args.adam_betaa if hasattr(_lowerCamelCase,  "adam_beta2"				) else None,  adam_weight_decay=args.adam_weight_decay if hasattr(_lowerCamelCase,  "adam_weight_decay"				) else None,  adam_epsilon=args.adam_epsilon if hasattr(_lowerCamelCase,  "adam_epsilon"				) else None,  lr_scheduler=args.lr_scheduler if hasattr(_lowerCamelCase,  "lr_scheduler"				) else None,  lr_warmup_steps=args.lr_warmup_steps if hasattr(_lowerCamelCase,  "lr_warmup_steps"				) else None,  ema_inv_gamma=args.ema_inv_gamma if hasattr(_lowerCamelCase,  "ema_inv_gamma"				) else None,  ema_power=args.ema_power if hasattr(_lowerCamelCase,  "ema_power"				) else None,  ema_max_decay=args.ema_max_decay if hasattr(_lowerCamelCase,  "ema_max_decay"				) else None,  mixed_precision=args.mixed_precision,  )

		__lowercase				:		Dict												=				os.path.join(args.output_dir,  "README.md"				)
		model_card.save(_lowerCamelCase				)

def 						snake_case__       (					_lowerCamelCase,  _lowerCamelCase = None				)			->Tuple:






		"""simple docstring"""


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

def 						snake_case__       (					_lowerCamelCase = None,  _lowerCamelCase = None				)			->None:






		"""simple docstring"""


		if new_cache_dir is None:
				__lowercase				:		int												=				DIFFUSERS_CACHE
		if old_cache_dir is None:
				__lowercase				:		Tuple												=				old_diffusers_cache

		__lowercase				:		str												=				Path(_lowerCamelCase				).expanduser()
		__lowercase				:		Optional[int]												=				Path(_lowerCamelCase				).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				:		str												=				new_cache_dir / old_blob_path.relative_to(_lowerCamelCase				)
						new_blob_path.parent.mkdir(parents=_lowerCamelCase,  exist_ok=_lowerCamelCase				)
						os.replace(_lowerCamelCase,  _lowerCamelCase				)
						try:
								os.symlink(_lowerCamelCase,  _lowerCamelCase				)
						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).


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

if cache_version < 1:
						__A   :  Optional[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:
																		__A   :  Union[str, Any]					=      '\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__       (					_lowerCamelCase,  _lowerCamelCase = None				)			->str:






		"""simple docstring"""


		if variant is not None:
				__lowercase				:		str												=				weights_name.split("."				)
				__lowercase				:		str												=				splits[:-1] + [variant] + splits[-1:]
				__lowercase				:		Dict												=				".".join(_lowerCamelCase				)

		return weights_name





def 						snake_case__       (					_lowerCamelCase,  *,
    _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase,  _lowerCamelCase=None,  )			->str:






		"""simple docstring"""


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