






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


__UpperCAmelCase								=						get_logger(__name__)


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




def      lowercase__      (     __snake_case    :							Union[Dict, str, None] = None  ):


					'''simple docstring'''


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




def      lowercase__      (     __snake_case    :							str     ,       __snake_case    :							Optional[str] = None     ,       __snake_case    :							Optional[str] = None  ):


					'''simple docstring'''


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




def      lowercase__      (     __snake_case    :							List[Any]     ,       __snake_case    :							Tuple  ):


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

					UpperCAmelCase_    :      Any            =						args.hub_token if hasattr(__snake_case     ,       'hub_token'  ) else None
					UpperCAmelCase_    :      Any            =						get_full_repo_name(__snake_case     ,       token=__snake_case  )

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

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




def      lowercase__      (     __snake_case    :							Optional[str]     ,       __snake_case    :							Optional[str] = None  ):


					'''simple docstring'''


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




def      lowercase__      (     __snake_case    :							Optional[str] = None     ,       __snake_case    :							Optional[str] = None  ):


					'''simple docstring'''


					if new_cache_dir is None:
										UpperCAmelCase_    :      List[str]            =						DIFFUSERS_CACHE
					if old_cache_dir is None:
										UpperCAmelCase_    :      Optional[Any]            =						old_diffusers_cache

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


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

if cache_version < 1:
		__UpperCAmelCase								=						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:
						__UpperCAmelCase								=						'\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      lowercase__      (     __snake_case    :							str     ,       __snake_case    :							Optional[str] = None  ):


					'''simple docstring'''


					if variant is not None:
										UpperCAmelCase_    :      List[str]            =						weights_name.split('.'  )
										UpperCAmelCase_    :      List[Any]            =						splits[:-1] + [variant] + splits[-1:]
										UpperCAmelCase_    :      Union[str, Any]            =						'.'.join(__snake_case  )

					return weights_name






def      lowercase__      (     __snake_case    :							int     ,       *,
    __snake_case    :							Dict     ,       __snake_case    :							Any     ,       __snake_case    :							Tuple     ,       __snake_case    :							List[Any]     ,       __snake_case    :							Union[str, Any]     ,       __snake_case    :							Any     ,       __snake_case    :							str     ,       __snake_case    :							Dict     ,       __snake_case    :							str     ,       __snake_case    :							str     ,       __snake_case    :							List[str]=None     ,       ):


					'''simple docstring'''


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














from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__				   =		{
    "configuration_nllb_moe": [
        "NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "NllbMoeConfig",
    ]
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__				   =		[
         "NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST",
         "NllbMoeForConditionalGeneration",
         "NllbMoeModel",
         "NllbMoePreTrainedModel",
         "NllbMoeTop2Router",
         "NllbMoeSparseMLP",
     ]


if TYPE_CHECKING:
     from .configuration_nllb_moe import (
         NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
         NllbMoeConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_nllb_moe import (
              NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
              NllbMoeForConditionalGeneration,
              NllbMoeModel,
              NllbMoePreTrainedModel,
              NllbMoeSparseMLP,
              NllbMoeTopaRouter,
          )


else:
     import sys

     UpperCAmelCase__				   =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


